isinternal.h File Reference

#include "config.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#include <float.h>
#include "vbisam.h"
#include "byteswap.h"

Include dependency graph for isinternal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	VBLOCK
struct	VBKEY
struct	VBTREE
struct	DICTNODE
struct	DICTINFO
struct	VBFILE
struct	SLOGHDR

Macros
#define	_LFS64_LARGEFILE   1
#define	_LFS64_STDIO   1
#define	_FILE_OFFSET_BITS   64
#define	_LARGEFILE64_SOURCE   1
#define	__USE_LARGEFILE64   1
#define	__USE_FILE_OFFSET64   1
#define	QUADSIZE   8
#define	VB_OFFLEN_7F   0x7fffffffffffffffLL
#define	VB_OFFLEN_3F   0x3fffffffffffffffLL
#define	VB_OFFLEN_40   0x4000000000000000LL
#define	MAXSUBS   32 /* Maximum number of indexes per table */
#define	VB_MAX_FILES   128 /* Maximum number of open VBISAM files */
#define	VBISAM_LIB
#define	VB_HIDDEN
#define	O_BINARY   0
#define	likely(x)   (x)
#define	unlikely(x)   (x)
#define	MISALIGNED
#define	MAX_NODE_LENGTH   4096
#define	VB_NODE_MAX   4096
#define	MAX_ISREC_LENGTH   32511
#define	MAX_RESERVED_LENGTH   32768 /* Greater then MAX_ISREC_LENGTH */
#define	MAX_BUFFER_LENGTH   65536
#define	VBUNLOCK   0 /* Unlock */
#define	VBRDLOCK   1 /* A simple read lock, non-blocking */
#define	VBRDLCKW   2 /* A simple read lock, blocking */
#define	VBWRLOCK   3 /* An exclusive write lock, non-blocking */
#define	VBWRLCKW   4 /* An exclusive write lock, blocking */
#define	RECOV_C   0x00 /* Boring old buggy C-ISAM mode */
#define	RECOV_VB   0x01 /* New, improved error detection */
#define	RECOV_LK   0x02 /* Use locks in isrecover (See documentation) */
#define	VBNOTRANS   0 /* NOT in a transaction at all */
#define	VBBEGIN   1 /* An isbegin has been issued but no more */
#define	VBNEEDFLUSH   2 /* Something BEYOND just isbegin has been issued */
#define	VBCOMMIT   3 /* We're in 'iscommit' mode */
#define	VBROLLBACK   4 /* We're in 'isrollback' mode */
#define	VBRECOVER   5 /* We're in 'isrecover' mode */
#define	VBL_BUILD   ("BU")
#define	VBL_BEGIN   ("BW")
#define	VBL_CREINDEX   ("CI")
#define	VBL_CLUSTER   ("CL")
#define	VBL_COMMIT   ("CW")
#define	VBL_DELETE   ("DE")
#define	VBL_DELINDEX   ("DI")
#define	VBL_FILEERASE   ("ER")
#define	VBL_FILECLOSE   ("FC")
#define	VBL_FILEOPEN   ("FO")
#define	VBL_INSERT   ("IN")
#define	VBL_RENAME   ("RE")
#define	VBL_ROLLBACK   ("RW")
#define	VBL_SETUNIQUE   ("SU")
#define	VBL_UNIQUEID   ("UN")
#define	VBL_UPDATE   ("UP")

Typedefs
typedef unsigned char *	ucharptr

Functions
static int	inl_ldint (void *pclocation)
static void	inl_stint (int ivalue, void *pclocation)
static int	inl_ldlong (void *pclocation)
static void	inl_stlong (int lvalue, void *pclocation)
static off_t	inl_ldquad (void *pclocation)
static void	inl_stquad (off_t tvalue, void *pclocation)
int	ivbforceexit (const int ihandle)
int	ivbclose2 (const int ihandle)
void	ivbclose3 (const int ihandle)
int	ivbcheckkey (const int ihandle, struct keydesc *pskey, const int imode, int irowlength, const int iisbuild)
int	ivbtransbuild (const char *pcfilename, const int iminrowlen, const int imaxrowlen, struct keydesc *pskeydesc, const int imode)
int	ivbtranscreateindex (const int ihandle, struct keydesc *pskeydesc)
int	ivbtranscluster (void)
int	ivbtransdelete (const int ihandle, off_t trownumber, int irowlength)
int	ivbtransdeleteindex (const int ihandle, struct keydesc *pskeydesc)
int	ivbtranserase (const char *pcfilename)
int	ivbtransclose (const int ihandle, const char *pcfilename)
int	ivbtransopen (const int ihandle, const char *pcfilename)
int	ivbtransinsert (const int ihandle, const off_t trownumber, int irowlength, char *pcrow)
int	ivbtransrename (char *pcoldname, char *pcnewname)
int	ivbtranssetunique (const int ihandle, const off_t tuniqueid)
int	ivbtransuniqueid (const int ihandle, const off_t tuniqueid)
int	ivbtransupdate (const int ihandle, const off_t trownumber, const int ioldrowlen, const int inewrowlen, const char *pcrow)
int	ivbwriterow (const int ihandle, char *pcrow, const off_t trownumber)
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)
off_t	tvbnodecountgetnext (const int ihandle)
int	ivbnodefree (const int ihandle, const off_t tnodenumber)
int	ivbdatafree (const int ihandle, const off_t trownumber)
off_t	tvbnodeallocate (const int ihandle)
off_t	tvbdataallocate (const int ihandle)
int	ivbforcedataallocate (const int ihandle, const off_t trownumber)
void	vvbmakekey (const struct keydesc *pskeydesc, char *pcrow_buffer, unsigned char *pckeyvalue)
int	ivbkeysearch (const int ihandle, const int imode, const int ikeynumber, int ilength, unsigned char *pckeyvalue, off_t tdupnumber)
int	ivbkeylocaterow (const int ihandle, const int ikeynumber, off_t trownumber)
int	ivbkeyload (const int ihandle, const int ikeynumber, const int imode, const int isetcurr, struct VBKEY **ppskey)
void	vvbkeyvalueset (const int ihigh, struct keydesc *pskeydesc, unsigned char *pckeyvalue)
int	ivbkeyinsert (const int ihandle, struct VBTREE *pstree, const int ikeynumber, unsigned char *pckeyvalue, off_t trownode, off_t tdupnumber, struct VBTREE *pschild)
int	ivbkeydelete (const int ihandle, const int ikeynumber)
int	ivbkeycompare (const int ihandle, const int ikeynumber, int ilength, unsigned char *pckey1, unsigned char *pckey2)
int	ivbenter (const int ihandle, const unsigned int imodifying, const unsigned int ispecial)
int	ivbexit (const int ihandle)
int	ivbfileopenlock (const int ihandle, const int imode)
int	ivbdatalock (const int ihandle, const int imode, const off_t trownumber)
int	ivbopen (const char *pcfilename, const int iflags, const mode_t tmode)
int	ivbclose (const int ihandle)
off_t	tvblseek (const int ihandle, off_t toffset, const int iwhence)
ssize_t	tvbread (const int ihandle, void *pvbuffer, const size_t tcount)
ssize_t	tvbwrite (const int ihandle, const void *pvbuffer, const size_t tcount)
int	ivbblockread (const int ihandle, const int iisindex, const off_t tblocknumber, char *cbuffer)
int	ivbblockwrite (const int ihandle, const int iisindex, const off_t tblocknumber, const char *cbuffer)
int	ivblock (const int ihandle, const off_t toffset, const off_t tlength, const int imode)
struct VBLOCK *	psvblockallocate (const int ihandle)
void	vvblockfree (struct VBLOCK *pslock)
struct VBTREE *	psvbtreeallocate (const int ihandle)
void	vvbtreeallfree (const int ihandle, const int ikeynumber, struct VBTREE *pstree)
struct VBKEY *	psvbkeyallocate (const int ihandle, const int ikeynumber)
void	vvbkeyallfree (const int ihandle, const int ikeynumber, struct VBTREE *pstree)
void	vvbkeyfree (const int ihandle, const int ikeynumber, struct VBKEY *pskey)
void	vvbkeyunmalloc (const int ihandle, const int ikeynumber)
void *	pvvbmalloc (const size_t size)
void	vvbfree (void *mptr)
void	vvbunmalloc (void)
int	ivbnodeload (const int ihandle, const int ikeynumber, struct VBTREE *pstree, const off_t tnodenumber, const int iprevlvl)
int	ivbnodesave (const int ihandle, const int ikeynumber, struct VBTREE *pstree, const off_t tnodenumber, const int imode, const int iposn)

Variables
int	ivbintrans
int	ivblogfilehandle
int	ivbmaxusedhandle
struct DICTINFO *	psvbfile [128+1]
struct VBFILE	svbfile [128 *3]

Macro Definition Documentation

#define __USE_FILE_OFFSET64   1

Definition at line 36 of file isinternal.h.

#define __USE_LARGEFILE64   1

Definition at line 35 of file isinternal.h.

#define _FILE_OFFSET_BITS   64

Definition at line 33 of file isinternal.h.

#define _LARGEFILE64_SOURCE   1

Definition at line 34 of file isinternal.h.

#define _LFS64_LARGEFILE   1

Definition at line 31 of file isinternal.h.

#define _LFS64_STDIO   1

Definition at line 32 of file isinternal.h.

#define likely

(

x

)

(x)

Definition at line 146 of file isinternal.h.

#define MAX_BUFFER_LENGTH   65536

Definition at line 291 of file isinternal.h.

Referenced by ircvchecktrans(), and isrecover().

#define MAX_ISREC_LENGTH   32511

Definition at line 289 of file isinternal.h.

#define MAX_NODE_LENGTH   4096

Definition at line 283 of file isinternal.h.

Referenced by isbuild(), isopen(), and ttailnode().

#define MAX_RESERVED_LENGTH   32768 /* Greater then MAX_ISREC_LENGTH */

Definition at line 290 of file isinternal.h.

Referenced by iprocessdelete(), isbuild(), isopen(), ivbdataread(), and ivbdatawrite().

#define MAXSUBS   32 /* Maximum number of indexes per table */

Definition at line 119 of file isinternal.h.

Referenced by iindexcheck(), ipostamble(), irowdelete(), irowinsert(), isaddindex(), isdelindex(), isopen(), ivbclose2(), ivbclose3(), ivbenter(), and vrebuildkeys().

#define MISALIGNED

Definition at line 157 of file isinternal.h.

Referenced by inl_ldint(), inl_ldlong(), inl_ldquad(), inl_stint(), inl_stlong(), and inl_stquad().

#define O_BINARY   0

Definition at line 133 of file isinternal.h.

#define QUADSIZE   8

Definition at line 108 of file isinternal.h.

Referenced by iaddkeydescriptor(), idatafreecheck(), idelnodes(), iindexfreecheck(), ipreamble(), iquicknodesave(), ircvdelete(), ircvinsert(), ircvupdate(), isbuild(), isopen(), ivbcheckkey(), ivbdatafree(), ivbdataread(), ivbdatawrite(), ivbforcedataallocate(), ivbkeycompare(), ivbnodefree(), ivbnodeload(), ivbnodesave(), ivbrollmeback(), ivbtransdelete(), ivbtransinsert(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), ivbvarlendelete(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), tvbnodeallocate(), and vvbkeyvalueset().

#define RECOV_C   0x00 /* Boring old buggy C-ISAM mode */

Definition at line 301 of file isinternal.h.

#define RECOV_LK   0x02 /* Use locks in isrecover (See documentation) */

Definition at line 303 of file isinternal.h.

#define RECOV_VB   0x01 /* New, improved error detection */

Definition at line 302 of file isinternal.h.

Referenced by ircvchecktrans().

#define unlikely

(

x

)

(x)

Definition at line 147 of file isinternal.h.

#define VB_HIDDEN

Definition at line 129 of file isinternal.h.

#define VB_MAX_FILES   128 /* Maximum number of open VBISAM files */

Definition at line 120 of file isinternal.h.

Referenced by ircvcommit(), isbuild(), isopen(), isrecover(), ivbopen(), ivbrollmeback(), ivbrollmeforward(), and vcloseall().

#define VB_NODE_MAX   4096

Definition at line 288 of file isinternal.h.

Referenced by iaddkeydescriptor(), idelnodes(), iindexcheck(), ipreamble(), isbuild(), isopen(), ivbdatafree(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbexit(), ivbfileopenlock(), ivbforceexit(), ivbnodefree(), ivbnodesave(), tdelkeydescriptor(), and ttailnode().

#define VB_OFFLEN_3F   0x3fffffffffffffffLL

Definition at line 110 of file isinternal.h.

Referenced by ivbdatalock(), ivbenter(), and ivbexit().

#define VB_OFFLEN_40   0x4000000000000000LL

Definition at line 111 of file isinternal.h.

Referenced by ivbdatalock().

#define VB_OFFLEN_7F   0x7fffffffffffffffLL

Definition at line 109 of file isinternal.h.

Referenced by ivbfileopenlock().

#define VBBEGIN   1 /* An isbegin has been issued but no more */

Definition at line 307 of file isinternal.h.

Referenced by isbegin(), isclose(), iscommit(), isrollback(), ivbtransbuild(), ivbtransclose(), ivbtranscreateindex(), ivbtransdelete(), ivbtransdeleteindex(), ivbtranserase(), ivbtransinsert(), ivbtransopen(), ivbtransrename(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), and iwritetrans().

#define VBCOMMIT   3 /* We're in 'iscommit' mode */

Definition at line 309 of file isinternal.h.

Referenced by iprocessdelete(), iscommit(), and ivbenter().

#define VBISAM_LIB

Definition at line 122 of file isinternal.h.

#define VBL_BEGIN   ("BW")

Definition at line 469 of file isinternal.h.

Referenced by ircvchecktrans(), isrecover(), ivbrollmeback(), ivbrollmeforward(), and iwritebegin().

#define VBL_BUILD   ("BU")

Definition at line 468 of file isinternal.h.

Referenced by isrecover(), and ivbtransbuild().

#define VBL_CLUSTER   ("CL")

Definition at line 471 of file isinternal.h.

Referenced by isrecover().

#define VBL_COMMIT   ("CW")

Definition at line 472 of file isinternal.h.

Referenced by ircvchecktrans(), iscommit(), and isrecover().

#define VBL_CREINDEX   ("CI")

Definition at line 470 of file isinternal.h.

Referenced by isrecover(), and ivbtranscreateindex().

#define VBL_DELETE   ("DE")

Definition at line 473 of file isinternal.h.

Referenced by isrecover(), ivbrollmeback(), ivbrollmeforward(), and ivbtransdelete().

#define VBL_DELINDEX   ("DI")

Definition at line 474 of file isinternal.h.

Referenced by isrecover(), and ivbtransdeleteindex().

#define VBL_FILECLOSE   ("FC")

Definition at line 476 of file isinternal.h.

Referenced by isrecover(), ivbrollmeback(), ivbrollmeforward(), and ivbtransclose().

#define VBL_FILEERASE   ("ER")

Definition at line 475 of file isinternal.h.

Referenced by isrecover(), and ivbtranserase().

#define VBL_FILEOPEN   ("FO")

Definition at line 477 of file isinternal.h.

Referenced by isrecover(), ivbrollmeback(), ivbrollmeforward(), and ivbtransopen().

#define VBL_INSERT   ("IN")

Definition at line 478 of file isinternal.h.

Referenced by isrecover(), ivbrollmeback(), and ivbtransinsert().

#define VBL_RENAME   ("RE")

Definition at line 479 of file isinternal.h.

Referenced by isrecover(), and ivbtransrename().

#define VBL_ROLLBACK   ("RW")

Definition at line 480 of file isinternal.h.

Referenced by ircvchecktrans(), isrecover(), and isrollback().

#define VBL_SETUNIQUE   ("SU")

Definition at line 481 of file isinternal.h.

Referenced by isrecover(), and ivbtranssetunique().

#define VBL_UNIQUEID   ("UN")

Definition at line 482 of file isinternal.h.

Referenced by isrecover(), and ivbtransuniqueid().

#define VBL_UPDATE   ("UP")

Definition at line 483 of file isinternal.h.

Referenced by isrecover(), ivbrollmeback(), and ivbtransupdate().

#define VBNEEDFLUSH   2 /* Something BEYOND just isbegin has been issued */

Definition at line 308 of file isinternal.h.

Referenced by isclose(), islogclose(), ivbtransbuild(), ivbtranscreateindex(), ivbtransdelete(), ivbtransdeleteindex(), ivbtranserase(), ivbtransinsert(), ivbtransopen(), ivbtransrename(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), and iwritetrans().

#define VBNOTRANS   0 /* NOT in a transaction at all */

Definition at line 306 of file isinternal.h.

Referenced by iprocessdelete(), iscommit(), islogclose(), isopen(), isrelcurr(), isrelease(), isrollback(), and ivbenter().

#define VBRDLCKW   2 /* A simple read lock, blocking */

Definition at line 296 of file isinternal.h.

Referenced by ivblock().

#define VBRDLOCK   1 /* A simple read lock, non-blocking */

Definition at line 295 of file isinternal.h.

Referenced by ivbenter(), ivbfileopenlock(), and ivblock().

#define VBRECOVER   5 /* We're in 'isrecover' mode */

Definition at line 311 of file isinternal.h.

Referenced by isclose(), and isrecover().

#define VBROLLBACK   4 /* We're in 'isrollback' mode */

Definition at line 310 of file isinternal.h.

Referenced by iprocessdelete(), isrollback(), ivbenter(), and ivbtransclose().

#define VBUNLOCK   0 /* Unlock */

Definition at line 294 of file isinternal.h.

Referenced by idemotelocks(), isrelcurr(), isrelease(), isrelrec(), isunlock(), ivbdatalock(), ivbexit(), ivbfileopenlock(), ivblock(), ivbwriterow(), and iwritetrans().

#define VBWRLCKW   4 /* An exclusive write lock, blocking */

Definition at line 298 of file isinternal.h.

Referenced by isread(), istartrownumber(), ivblock(), and iwritetrans().

#define VBWRLOCK   3 /* An exclusive write lock, non-blocking */

Definition at line 297 of file isinternal.h.

Referenced by iprocessdelete(), islock(), isread(), isrewcurr(), isrewrec(), isrewrite(), istartrownumber(), ivbenter(), ivbfileopenlock(), ivblock(), and ivbwriterow().

Typedef Documentation

typedef unsigned char* ucharptr

Definition at line 150 of file isinternal.h.

Function Documentation

static int inl_ldint ( void *  pclocation )

inlinestatic

Definition at line 170 of file isinternal.h.

References MISALIGNED, and VB_BSWAP_16.

Referenced by iaddkeydescriptor(), idatafreecheck(), idelnodes(), iindexfreecheck(), iquicknodesave(), ircvbegin(), ircvbuild(), ircvchecktrans(), ircvcluster(), ircvcommit(), ircvcreateindex(), ircvdelete(), ircvdeleteindex(), ircvfileclose(), ircvfileerase(), ircvfileopen(), ircvfilerename(), ircvinsert(), ircvrollback(), ircvsetunique(), ircvuniqueid(), ircvupdate(), isopen(), isrecover(), ivbdatafree(), ivbdataread(), ivbdatawrite(), ivbforcedataallocate(), ivbkeycompare(), ivbnodefree(), ivbnodeload(), ivbrollmeback(), ivbrollmeforward(), ivbvarlendelete(), ivbvarlenread(), ivbvarlenwrite(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), and tvbnodeallocate().

{
#ifndef WORDS_BIGENDIAN
    return (int)VB_BSWAP_16(*(unsigned short MISALIGNED *)pclocation);
#else
    short   ivalue = 0;
    unsigned char   *pctemp = (unsigned char *) &ivalue;
    unsigned char   *pctemp2 = (unsigned char *) pclocation;

    *(pctemp + 0) = *(pctemp2 + 0);
    *(pctemp + 1) = *(pctemp2 + 1);
    return (int)ivalue;
#endif
}

Here is the caller graph for this function:

static int inl_ldlong ( void *  pclocation )

inlinestatic

Definition at line 209 of file isinternal.h.

References MISALIGNED, and VB_BSWAP_32.

Referenced by ivbkeycompare().

{
#ifndef WORDS_BIGENDIAN
    return VB_BSWAP_32(*(unsigned int MISALIGNED *)pclocation);
#else
    int lvalue;

    memcpy((unsigned char *)&lvalue, (unsigned char *)pclocation, 4);
    return lvalue;
#endif
}

Here is the caller graph for this function:

static off_t inl_ldquad ( void *  pclocation )

inlinestatic

Definition at line 238 of file isinternal.h.

References MISALIGNED, VB_BSWAP_32, and VB_BSWAP_64.

Referenced by iaddkeydescriptor(), icheckkeydesc(), idatafreecheck(), idelnodes(), iindexfreecheck(), imakekeysfromdata(), ircvdelete(), ircvinsert(), ircvsetunique(), ircvuniqueid(), ircvupdate(), isopen(), issetunique(), istartrownumber(), isuniqueid(), ivbdatafree(), ivbdataread(), ivbenter(), ivbexit(), ivbforcedataallocate(), ivbkeycompare(), ivbnodefree(), ivbnodeload(), ivbnodesave(), ivbrollmeback(), ivbrollmeforward(), ivbvarlendelete(), ivbvarlenread(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), tvbdatacountgetnext(), tvbnodeallocate(), tvbnodecountgetnext(), and vrebuildindexfree().

{

#ifndef WORDS_BIGENDIAN
#if ISAMMODE == 1
    return VB_BSWAP_64(*(unsigned long long MISALIGNED *)pclocation);
#else
    return VB_BSWAP_32(*(unsigned int MISALIGNED *)pclocation);
#endif
#else
    off_t   tvalue = 0;

#if ISAMMODE == 1
    memcpy((unsigned char *)&tvalue, (unsigned char *)pclocation, 8);
#else
    memcpy((unsigned char *)&tvalue, (unsigned char *)pclocation, 4);
#endif
    return tvalue;
#endif
}

Here is the caller graph for this function:

static void inl_stint ( int  ivalue, void *  pclocation  )

inlinestatic

Definition at line 190 of file isinternal.h.

References MISALIGNED, and VB_BSWAP_16.

Referenced by iaddkeydescriptor(), iindexcheck(), iquicknodesave(), irollbackall(), isaddindex(), isbuild(), isdelindex(), ivbdatafree(), ivbdatawrite(), ivbforcedataallocate(), ivbnodefree(), ivbnodesave(), ivbtransbuild(), ivbtransclose(), ivbtranscreateindex(), ivbtransdelete(), ivbtransdeleteindex(), ivbtransinsert(), ivbtransopen(), ivbtransrename(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), ivbvarlendelete(), ivbvarlenwrite(), iwritetrans(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), tvbnodeallocate(), vtranshdr(), and vvbkeyvalueset().

{
#ifndef WORDS_BIGENDIAN
    *(unsigned short MISALIGNED *)pclocation = VB_BSWAP_16((unsigned short)ivalue);
#else
    unsigned char   *pctemp = (char *) &ivalue;
    unsigned char   *pctemp2 = (unsigned char *) pclocation;

    *(pctemp2 + 0) = *(pctemp + 0 + INTSIZE);
    *(pctemp2 + 1) = *(pctemp + 1 + INTSIZE);
#endif
    return;
}

Here is the caller graph for this function:

static void inl_stlong ( int  lvalue, void *  pclocation  )

inlinestatic

Definition at line 226 of file isinternal.h.

References MISALIGNED, and VB_BSWAP_32.

Referenced by vtranshdr(), and vvbkeyvalueset().

{
#ifndef WORDS_BIGENDIAN
    *(unsigned int MISALIGNED *)pclocation = VB_BSWAP_32((unsigned int)lvalue);
#else
    memcpy((unsigned char *)pclocation, (unsigned char *)&lvalue, 4);
#endif
    return;
}

Here is the caller graph for this function:

static void inl_stquad ( off_t  tvalue, void *  pclocation  )

inlinestatic

Definition at line 260 of file isinternal.h.

References MISALIGNED, VB_BSWAP_32, and VB_BSWAP_64.

Referenced by iaddkeydescriptor(), idatafreecheck(), iindexfreecheck(), ipostamble(), iquicknodesave(), isbuild(), issetunique(), isuniqueid(), ivbdatafree(), ivbdatawrite(), ivbexit(), ivbforcedataallocate(), ivbnodefree(), ivbnodesave(), ivbrollmeforward(), ivbtransdelete(), ivbtransinsert(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), ivbvarlendelete(), ivbvarlenwrite(), ttailnode(), tvbdataallocate(), tvbdatacountgetnext(), tvbnodeallocate(), tvbnodecountgetnext(), and vrebuildindexfree().

{
#ifndef WORDS_BIGENDIAN
#if ISAMMODE == 1
    *(unsigned long long MISALIGNED *)pclocation = VB_BSWAP_64((unsigned long long)tvalue);
#else
    *(unsigned int MISALIGNED *)pclocation = VB_BSWAP_32((unsigned int)tvalue);
#endif
#else
#if ISAMMODE == 1
    memcpy((unsigned char *)pclocation, (unsigned char *)&tvalue, 8);
#else
    memcpy((unsigned char *)pclocation, (unsigned char *)&tvalue, 4);
#endif
#endif
    return;
}

Here is the caller graph for this function:

int ivbblockread	(	const int	ihandle,
		const int	iisindex,
		const off_t	tblocknumber,
		char *	cbuffer
	)

Definition at line 137 of file vblowlevel.c.

References DICTINFO::idatahandle, DICTINFO::iindexhandle, DICTINFO::inodesize, tvblseek(), and tvbread().

Referenced by iaddkeydescriptor(), icheckkey(), icheckkeydesc(), idatafreecheck(), idelnodes(), iindexfreecheck(), iquicknodesave(), isopen(), ivbdatafree(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbfileopenlock(), ivbforcedataallocate(), ivbnodefree(), ivbnodeload(), ivbvarlendelete(), ivbvarlenread(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), and tvbnodeallocate().

{
    struct DICTINFO *psvbptr;
    off_t       toffset;
    ssize_t     tresult;
    int     thandle;

    psvbptr = psvbfile[ihandle];
    toffset = (off_t) ((tblocknumber - 1) * psvbptr->inodesize);
    if (iisindex) {
        thandle = psvbptr->iindexhandle;
    } else {
        thandle = psvbptr->idatahandle;
    }
    if (tvblseek (thandle, toffset, SEEK_SET) != toffset) {
        return EIO;
    }

    tresult = tvbread (thandle, cbuffer, (size_t) psvbptr->inodesize);
    if (!iisindex && tresult == 0) {
        tresult = (ssize_t) psvbptr->inodesize;
        memset (cbuffer, 0, (size_t)psvbptr->inodesize);
    }
    if (tresult != (ssize_t)psvbptr->inodesize) {
        return EIO;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbblockwrite	(	const int	ihandle,
		const int	iisindex,
		const off_t	tblocknumber,
		const char *	cbuffer
	)

Definition at line 167 of file vblowlevel.c.

References DICTINFO::idatahandle, DICTINFO::iindexhandle, DICTINFO::inodesize, tvblseek(), and tvbwrite().

Referenced by iaddkeydescriptor(), iindexcheck(), iquicknodesave(), isbuild(), ivbdatafree(), ivbdatawrite(), ivbexit(), ivbforcedataallocate(), ivbforceexit(), ivbnodefree(), ivbnodesave(), ivbvarlendelete(), ivbvarlenwrite(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), and tvbnodeallocate().

{
    struct DICTINFO *psvbptr;
    off_t       toffset;
    ssize_t     tresult;
    int     thandle;

    psvbptr = psvbfile[ihandle];
    toffset = (off_t) ((tblocknumber - 1) * psvbptr->inodesize);
    if (iisindex) {
        thandle = psvbptr->iindexhandle;
    } else {
        thandle = psvbptr->idatahandle;
    }
/* RXW
    tresult = tvblseek (thandle, toffset, SEEK_SET);
    if (tresult == (off_t) -1) {
*/
    if (tvblseek (thandle, toffset, SEEK_SET) != toffset) {
        return EIO;
    }

    tresult = tvbwrite (thandle, cbuffer, (size_t) psvbptr->inodesize);
    if (tresult != (ssize_t)psvbptr->inodesize) {
        return EIO;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbcheckkey	(	const int	ihandle,
		struct keydesc *	pskey,
		const int	imode,
		int	irowlength,
		const int	iisbuild
	)

Definition at line 124 of file isread.c.

References DICTINFO::iminrowlength, DICTINFO::inkeys, iserrno, DICTINFO::pskeydesc, psvbfile, and QUADSIZE.

Referenced by isaddindex(), isbuild(), isdelindex(), and isstart().

{
    struct DICTINFO *psvbptr;
    struct keydesc  *pslocalkey;
    struct keypart  *pskptr;
    struct keypart  *psklptr;
    int     iloop, ipart, itype, ilocalkeylength;

    psvbptr = psvbfile[ihandle];
    if (imode) {
        irowlength = psvbptr->iminrowlength;
    }
    if (imode < 2) {
        /* Basic key validity test */
        pskey->k_len = 0;
        if (pskey->k_flags < 0 || pskey->k_flags > COMPRESS + ISDUPS) {
            goto vbcheckkey_exit;
        }
        if (pskey->k_nparts >= NPARTS || pskey->k_nparts < 0) {
            goto vbcheckkey_exit;
        }
        if (pskey->k_nparts == 0 && !iisbuild) {
            goto vbcheckkey_exit;
        }
        for (ipart = 0; ipart < pskey->k_nparts; ipart++) {
            /* Wierdly enough, a single keypart CAN span multiple instances */
            /* EG: Part number 1 might contain 4 long values */
            pskptr = &pskey->k_part[ipart];
            pskey->k_len += pskptr->kp_leng;
            if (pskey->k_len > VB_MAX_KEYLEN) {
                goto vbcheckkey_exit;
            }
            itype = pskptr->kp_type & ~ISDESC;
            switch (itype) {
            case CHARTYPE:
                break;

            case INTTYPE:
                if (pskptr->kp_leng % INTSIZE) {
                    goto vbcheckkey_exit;
                }
                break;

            case LONGTYPE:
                if (pskptr->kp_leng % LONGSIZE) {
                    goto vbcheckkey_exit;
                }
                break;

            case QUADTYPE:
                if (pskptr->kp_leng % QUADSIZE) {
                    goto vbcheckkey_exit;
                }
                break;

            case FLOATTYPE:
                if (pskptr->kp_leng % FLOATSIZE) {
                    goto vbcheckkey_exit;
                }
                break;

            case DOUBLETYPE:
                if (pskptr->kp_leng % DOUBLESIZE) {
                    goto vbcheckkey_exit;
                }
                break;

            default:
                goto vbcheckkey_exit;
            }
            if (pskptr->kp_start + pskptr->kp_leng > irowlength) {
                goto vbcheckkey_exit;
            }
            if (pskptr->kp_start < 0) {
                goto vbcheckkey_exit;
            }
        }
        if (!imode) {
            return 0;
        }
    }

    /* Check whether the key already exists */
    for (iloop = 0; iloop < psvbptr->inkeys; iloop++) {
        pslocalkey = psvbptr->pskeydesc[iloop];
        if (pslocalkey->k_nparts != pskey->k_nparts) {
            continue;
        }
        ilocalkeylength = 0;
        for (ipart = 0; ipart < pslocalkey->k_nparts; ipart++) {
            pskptr = &pskey->k_part[ipart];
            psklptr = &pslocalkey->k_part[ipart];
            if (psklptr->kp_start != pskptr->kp_start) {
                break;
            }
            if (psklptr->kp_leng != pskptr->kp_leng) {
                break;
            }
            if (psklptr->kp_type != pskptr->kp_type) {
                break;
            }
            ilocalkeylength += pskptr->kp_leng;
        }
        if (ipart == pslocalkey->k_nparts) {
            pskey->k_len = ilocalkeylength;
            break;  /* found */
        }
    }
    if (iloop == psvbptr->inkeys) {
        if (imode == 2) {
            goto vbcheckkey_exit;
        }
        return iloop;
    }
    if (imode == 1) {
        goto vbcheckkey_exit;
    }
    return iloop;

vbcheckkey_exit:
    iserrno = EBADKEY;
    return -1;
}

Here is the caller graph for this function:

int ivbclose

(

const int

ihandle

)

Definition at line 93 of file vblowlevel.c.

References VBFILE::irefcount, and svbfile.

Referenced by isbuild(), islogclose(), isopen(), and ivbclose2().

{
    if (!svbfile[ihandle].irefcount) {
        errno = ENOENT;
        return -1;
    }
    svbfile[ihandle].irefcount--;
    if (!svbfile[ihandle].irefcount) {
        return close (svbfile[ihandle].ihandle);
    }
    return 0;
}

Here is the caller graph for this function:

int ivbclose2

(

const int

ihandle

)

Definition at line 83 of file isopen.c.

References DICTINFO::cfilename, DICTINFO::idatahandle, DICTINFO::iindexhandle, DICTINFO::iisopen, iserrno, isrelease(), DICTINFO::itransyet, ivbclose(), ivbtransclose(), MAXSUBS, NULL, DICTINFO::pskeycurr, VBFILE::pslockhead, VBFILE::pslocktail, VBLOCK::psnext, psvbfile, svbfile, DICTINFO::tdupnumber, DICTINFO::trownumber, and vvblockfree().

Referenced by iscleanup(), isclose(), iscommit(), and isrollback().

{
    struct VBLOCK   *psrowlock;
    struct DICTINFO *psvbptr;
    int     iloop;
    int     iindexhandle;

    psvbptr = psvbfile[ihandle];
    psvbptr->iisopen = 0;   /* It's a LIE, but so what! */
    isrelease (ihandle);
    iserrno = ivbtransclose (ihandle, psvbptr->cfilename);
    if (ivbclose (psvbptr->idatahandle)) {
        iserrno = errno;
    }
    psvbptr->idatahandle = -1;
    if (ivbclose (psvbptr->iindexhandle)) {
        iserrno = errno;
    }
    iindexhandle = psvbptr->iindexhandle;
    while (svbfile[iindexhandle].pslockhead) {
        psrowlock = svbfile[iindexhandle].pslockhead->psnext;
        vvblockfree (svbfile[iindexhandle].pslockhead);
        svbfile[iindexhandle].pslockhead = psrowlock;
    }
    svbfile[iindexhandle].pslocktail = NULL;
    psvbptr->iindexhandle = -1;
/* RXW
    psvbptr->trownumber = -1;
    psvbptr->tdupnumber = -1;
*/
    psvbptr->trownumber = 0;
    psvbptr->tdupnumber = 0;
    psvbptr->iisopen = 2;   /* Only buffers remain! */
    psvbptr->itransyet = 0;
    for (iloop = 0; iloop < MAXSUBS; iloop++) {
        psvbptr->pskeycurr[iloop] = NULL;
    }

    return (iserrno ? -1 : 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ivbclose3

(

const int

ihandle

)

Definition at line 125 of file isopen.c.

References DICTINFO::cfilename, MAXSUBS, NULL, DICTINFO::ppcrowbuffer, DICTINFO::pskeydesc, DICTINFO::pstree, psvbfile, vvbfree(), vvbkeyunmalloc(), and vvbtreeallfree().

Referenced by isbuild(), iscleanup(), iserase(), and isfullclose().

{
    struct DICTINFO *psvbptr;
    int     iloop;

    psvbptr = psvbfile[ihandle];
    if (!psvbptr) {
        return;
    }
    for (iloop = 0; iloop < MAXSUBS; iloop++) {
        vvbtreeallfree (ihandle, iloop, psvbptr->pstree[iloop]);
        if (psvbptr->pskeydesc[iloop]) {
            vvbkeyunmalloc (ihandle, iloop);
            vvbfree (psvbptr->pskeydesc[iloop]);
        }
    }
    if (psvbptr->cfilename) {
        free (psvbptr->cfilename);
    }
    if (psvbptr->ppcrowbuffer) {
        free (psvbptr->ppcrowbuffer);
    }
    vvbfree (psvbptr);
    psvbfile[ihandle] = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbdatafree	(	const int	ihandle,
		const off_t	trownumber
	)

Definition at line 150 of file vbindexio.c.

References DICTNODE::cdatacount, DICTNODE::cdatafree, cvbnodetmp, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, iserrno, ivbblockread(), ivbblockwrite(), psvbfile, QUADSIZE, DICTINFO::sdictnode, tvbnodeallocate(), and VB_NODE_MAX.

Referenced by iprocessdelete(), iswrcurr(), iswrite(), ivbforcedataallocate(), ivbrollmeback(), ivbrollmeforward(), and vrebuilddatafree().

{
    struct DICTINFO *psvbptr;
    off_t       theadnode, tnodenumber;
    int     ilengthused, iresult;

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

    if (inl_ldquad (psvbptr->sdictnode.cdatacount) == trownumber) {
        inl_stquad (trownumber - 1, psvbptr->sdictnode.cdatacount);
        psvbptr->iisdictlocked |= 0x02;
        return 0;
    }

    theadnode = inl_ldquad (psvbptr->sdictnode.cdatafree);
    if (theadnode != 0) {
        iresult = ivbblockread (ihandle, 1, theadnode, cvbnodetmp);
        if (iresult) {
            return iresult;
        }
/* C-ISAM is not 100% C-ISAM compatible */
#if ISAMMODE == 1
        if (cvbnodetmp[psvbptr->inodesize - 2] != 0x7f) {
            return EBADFILE;
        }
#endif
        if (cvbnodetmp[psvbptr->inodesize - 3] != -1) {
            return EBADFILE;
        }
        ilengthused = inl_ldint (cvbnodetmp);
        if (ilengthused < psvbptr->inodesize - (QUADSIZE + 3)) {
            /* We need to add trownumber to the current node */
            inl_stquad ((off_t) trownumber, cvbnodetmp + ilengthused);
            ilengthused += QUADSIZE;
            inl_stint (ilengthused, cvbnodetmp);
            iresult = ivbblockwrite (ihandle, 1, theadnode, cvbnodetmp);
            return iresult;
        }
    }
    /* We need to allocate a new row-free node! */
    /* We append any existing nodes using the next pointer from the new node */
    tnodenumber = tvbnodeallocate (ihandle);
    if (tnodenumber == (off_t)-1) {
        return iserrno;
    }
    memset (cvbnodetmp, 0, VB_NODE_MAX);
    cvbnodetmp[psvbptr->inodesize - 2] = 0x7f;
    cvbnodetmp[psvbptr->inodesize - 3] = -1;
    inl_stint (INTSIZE + (2 * QUADSIZE), cvbnodetmp);
    inl_stquad (theadnode, &cvbnodetmp[INTSIZE]);
    inl_stquad (trownumber, &cvbnodetmp[INTSIZE + QUADSIZE]);
    iresult = ivbblockwrite (ihandle, 1, tnodenumber, cvbnodetmp);
    if (iresult) {
        return iresult;
    }
    inl_stquad (tnodenumber, psvbptr->sdictnode.cdatafree);
    psvbptr->iisdictlocked |= 0x02;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbdatalock	(	const int	ihandle,
		const int	imode,
		const off_t	trownumber
	)

Definition at line 432 of file vblocking.c.

References VBLOCK::ihandle, DICTINFO::iindexhandle, DICTINFO::iisdatalocked, ilockdelete(), ilockinsert(), DICTINFO::iopenmode, ivblock(), ivbmaxusedhandle, VBFILE::pslockhead, VBLOCK::psnext, psvbfile, svbfile, VBLOCK::trownumber, unlikely, VB_OFFLEN_3F, VB_OFFLEN_40, and VBUNLOCK.

Referenced by idemotelocks(), iprocessdelete(), islock(), isread(), isrelcurr(), isrelease(), isrelrec(), isrewcurr(), isrewrec(), isrewrite(), istartrownumber(), isunlock(), and ivbwriterow().

{
    struct DICTINFO *psvbptr;
    struct VBLOCK   *pslock;
    off_t       tlength = 1, toffset;
    int     iresult = 0;

    /* Sanity check - Is ihandle a currently open table? */
    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        return ENOTOPEN;
    }
    psvbptr = psvbfile[ihandle];
    if (!psvbptr) {
        return ENOTOPEN;
    }
    if (psvbptr->iopenmode & ISEXCLLOCK) {
        return 0;
    }
    /*
     * If this is a FILE (un)lock (row = 0), then we may as well free ALL
     * locks. Even if CISAMLOCKS is set, we do this!
     */
    if (trownumber == 0) {
        for (pslock = svbfile[psvbptr->iindexhandle].pslockhead; pslock;
             pslock = pslock->psnext) {
            ivbdatalock (ihandle, VBUNLOCK, pslock->trownumber);
        }
        tlength = VB_OFFLEN_3F;
        if (imode == VBUNLOCK) {
            psvbptr->iisdatalocked = 0;
        } else {
            psvbptr->iisdatalocked = 1;
        }
    } else if (imode == VBUNLOCK) {
        iresult = ilockdelete (ihandle, trownumber);
    }
    if (!iresult) {
        toffset = VB_OFFLEN_40;
        iresult = ivblock (psvbptr->iindexhandle, toffset + trownumber,
                tlength, imode);
        if (iresult != 0) {
            return ELOCKED;
        }
    }
    if ((imode != VBUNLOCK) && trownumber) {
        return ilockinsert (ihandle, trownumber);
    }
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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:

int ivbenter	(	const int	ihandle,
		const unsigned int	imodifying,
		const unsigned int	ispecial
	)

Definition at line 178 of file vblocking.c.

References DICTNODE::ctransnumber, cvbnodetmp, DICTINFO::iindexchanged, DICTINFO::iindexhandle, DICTINFO::iisdictlocked, DICTINFO::iisopen, inl_ldquad(), DICTINFO::iopenmode, iserrno, ivbblockread(), ivbexit(), ivbintrans, ivblock(), ivbmaxusedhandle, MAXSUBS, NULL, DICTINFO::pskeycurr, DICTINFO::pstree, psvbfile, DICTINFO::sdictnode, VBKEY::trownode, DICTINFO::ttranslast, unlikely, VB_NODE_MAX, VB_OFFLEN_3F, VBCOMMIT, VBNOTRANS, VBRDLOCK, VBROLLBACK, VBWRLOCK, and vvbtreeallfree().

Referenced by ircvinsert(), isaddindex(), ischeck(), isdelcurr(), isdelete(), isdelindex(), isdelrec(), isindexinfo(), isopen(), isread(), isrewcurr(), isrewrec(), isrewrite(), issetunique(), isstart(), isuniqueid(), iswrcurr(), iswrite(), ivbrollmeback(), and ivbrollmeforward().

{
    struct DICTINFO *psvbptr;
    off_t       tlength;
    size_t      iloop;
    int     ilockmode;
    char        cvbnodetmp[VB_NODE_MAX];

    if (unlikely(ihandle < 0 || ihandle > ivbmaxusedhandle)) {
        iserrno = EBADARG;
        return -1;
    }
    psvbptr = psvbfile[ihandle];
    if (unlikely(!psvbptr)) {
        iserrno = ENOTOPEN;
        return -1;
    }
    for (iloop = 0; iloop < MAXSUBS; iloop++) {
        if (psvbptr->pskeycurr[iloop]
            && psvbptr->pskeycurr[iloop]->trownode == -1) {
            psvbptr->pskeycurr[iloop] = NULL;
        }
    }
    iserrno = 0;
    if (psvbptr->iisopen && ivbintrans != VBCOMMIT && ivbintrans != VBROLLBACK) {
        iserrno = ENOTOPEN;
        return -1;
    }
    if ((psvbptr->iopenmode & ISTRANS) && ivbintrans == VBNOTRANS) {
        iserrno = ENOTRANS;
        return -1;
    }
    psvbptr->iindexchanged = 0;
    if (psvbptr->iopenmode & ISEXCLLOCK) {
        psvbptr->iisdictlocked |= 0x01;
        return 0;
    }
    if (psvbptr->iisdictlocked & 0x03) {
        iserrno = EBADARG;
        return -1;
    }
/* RXW
    if (imodifying) {
        ilockmode = VBWRLCKW;
    } else {
        ilockmode = VBRDLCKW;
    }
*/
    if (imodifying) {
        ilockmode = VBWRLOCK;
    } else {
        ilockmode = VBRDLOCK;
    }
    tlength = VB_OFFLEN_3F;
    psvbptr->iindexchanged = 0;
    if (ivblock (psvbptr->iindexhandle, (off_t)0, tlength, ilockmode)) {
        iserrno = EFLOCKED;
        return -1;
    }
    psvbptr->iisdictlocked |= 0x01;
/* RXW
    if (unlikely(ispecial)) {
        if (tvblseek (psvbptr->iindexhandle, (off_t)0, SEEK_SET)) {
            psvbptr->iisdictlocked = 0;
            ivbexit (ihandle);
            iserrno = EBADFILE;
            return -1;
        }
        if (tvbread (psvbptr->iindexhandle, cvbnodetmp, 8) != 8) {
            psvbptr->iisdictlocked = 0;
            ivbexit (ihandle);
            iserrno = EBADFILE;
            return -1;
        }
        psvbptr->inodesize = inl_ldint (&cvbnodetmp[6]) + 1;
    }
*/
    if (ivbblockread (ihandle, 1, (off_t) 1, cvbnodetmp)) {
        psvbptr->iisdictlocked = 0;
        ivbexit (ihandle);
        iserrno = EBADFILE;
        return -1;
    }
    memcpy ((void *)&psvbptr->sdictnode, (void *)cvbnodetmp,
        sizeof (struct DICTNODE));
    psvbptr->iisdictlocked |= 0x01;
/*
 * If we're in C-ISAM mode, then there is NO way to determine if a given node
 * has been updated by some other process.  Thus *ANY* change to the index
 * file needs to invalidate the ENTIRE cache for that table!!!
 * If we're in VBISAM 64-bit mode, then each node in the index table has a
 * stamp on it stating the transaction number when it was updated.  If this
 * stamp is BELOW that of the current transaction number, we know that the
 * associated VBTREE / VBKEY linked lists are still coherent!
 */
#if ISAMMODE == 0
    if (psvbptr->ttranslast !=
        inl_ldquad (psvbptr->sdictnode.ctransnumber)) {
        for (iloop = 0; iloop < MAXSUBS; iloop++) {
            if (psvbptr->pstree[iloop]) {
                vvbtreeallfree (ihandle, iloop,
                        psvbptr->pstree[iloop]);
            }
            psvbptr->pstree[iloop] = NULL;
        }
    }
#endif
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbexit

(

const int

ihandle

)

Definition at line 290 of file vblocking.c.

References DICTNODE::ctransnumber, cvbnodetmp, DICTINFO::iindexhandle, DICTINFO::iisdictlocked, DICTINFO::inkeys, inl_ldquad(), inl_stquad(), DICTINFO::iopenmode, iserrno, ivbblockwrite(), IVBBUFFERLEVEL, ivblock(), NULL, VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeycurr, VBTREE::pskeyfirst, VBKEY::psnext, VBKEY::psparent, VBTREE::psparent, psvbfile, DICTINFO::sdictnode, DICTINFO::ttranslast, VB_NODE_MAX, VB_OFFLEN_3F, VBUNLOCK, and vvbtreeallfree().

Referenced by ircvinsert(), isaddindex(), ischeck(), isdelcurr(), isdelete(), isdelindex(), isdelrec(), isindexinfo(), isopen(), isread(), isrewcurr(), isrewrec(), isrewrite(), isrollback(), issetunique(), isstart(), isuniqueid(), iswrcurr(), iswrite(), ivbenter(), ivbrollmeback(), and ivbrollmeforward().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey, *pskeycurr;
    off_t       tlength, ttransnumber;
    int     iresult = 0, iloop, iloop2, isaveerror;
    char        cvbnodetmp[VB_NODE_MAX];

    isaveerror = iserrno;
    psvbptr = psvbfile[ihandle];
    if (!psvbptr || (!psvbptr->iisdictlocked && !(psvbptr->iopenmode & ISEXCLLOCK))) {
        iserrno = EBADARG;
        return -1;
    }
    ttransnumber = inl_ldquad (psvbptr->sdictnode.ctransnumber);
    psvbptr->ttranslast = ttransnumber;
/* RXW
    if (psvbptr->iopenmode & ISEXCLLOCK) {
        return 0;
    }
*/
    if (psvbptr->iisdictlocked & 0x02) {
        if (!(psvbptr->iisdictlocked & 0x04)) {
            psvbptr->ttranslast = ttransnumber + 1;
            inl_stquad (ttransnumber + 1,
                    psvbptr->sdictnode.ctransnumber);
        }
        memset (cvbnodetmp, 0, VB_NODE_MAX);
        memcpy ((void *)cvbnodetmp, (void *)&psvbptr->sdictnode,
            sizeof (struct DICTNODE));
        iresult = ivbblockwrite (ihandle, 1, (off_t) 1, cvbnodetmp);
        if (iresult) {
            iserrno = EBADFILE;
        } else {
            iserrno = 0;
        }
    }
    tlength = VB_OFFLEN_3F;
    if (ivblock (psvbptr->iindexhandle, (off_t)0, tlength, VBUNLOCK)) {
        iserrno = errno;
        return -1;
    }
    psvbptr->iisdictlocked = 0;
    /* Free up any key/tree no longer wanted */
    for (iloop2 = 0; iloop2 < psvbptr->inkeys; iloop2++) {
        pskey = psvbptr->pskeycurr[iloop2];
        /*
         * This is a REAL fudge factor...
         * We simply free up all the dynamically allocated memory
         * associated with non-current nodes above a certain level.
         * In other words, we wish to keep the CURRENT key and all data
         * in memory above it for IVBBUFFERLEVEL levels.
         * Anything *ABOVE* that in the tree is to be purged with
         * EXTREME prejudice except for the 'current' tree up to the
         * root.
         */
        for (iloop = 0; pskey && iloop < IVBBUFFERLEVEL; iloop++) {
            if (pskey->psparent->psparent) {
                pskey = pskey->psparent->psparent->pskeycurr;
            } else {
                pskey = NULL;
            }
        }
        if (!pskey) {
            iserrno = isaveerror;
            return 0;
        }
        while (pskey) {
            for (pskeycurr = pskey->psparent->pskeyfirst; pskeycurr;
                 pskeycurr = pskeycurr->psnext) {
                if (pskeycurr != pskey && pskeycurr->pschild) {
                    vvbtreeallfree (ihandle, iloop2, pskeycurr->pschild);
                    pskeycurr->pschild = NULL;
                }
            }
            if (pskey->psparent->psparent) {
                pskey = pskey->psparent->psparent->pskeycurr;
            } else {
                pskey = NULL;
            }
        }
    }
    if (iresult) {
        return -1;
    }
    iserrno = isaveerror;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbfileopenlock	(	const int	ihandle,
		const int	imode
	)

Definition at line 380 of file vblocking.c.

References cvbnodetmp, DICTINFO::iindexhandle, ivbblockread(), ivblock(), ivbmaxusedhandle, psvbfile, DICTINFO::sdictnode, unlikely, VB_NODE_MAX, VB_OFFLEN_7F, VBRDLOCK, VBUNLOCK, and VBWRLOCK.

Referenced by ircvcreateindex(), ircvdeleteindex(), isbuild(), and isopen().

{
    struct DICTINFO *psvbptr;
    off_t       toffset;
    int     ilocktype;
/* RXW
    int     iresult;
*/
    char        cvbnodetmp[VB_NODE_MAX];

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

    toffset = VB_OFFLEN_7F;

    switch (imode) {
    case 0:
        ilocktype = VBUNLOCK;
        break;

    case 1:
        ilocktype = VBRDLOCK;
        break;

    case 2:
        ilocktype = VBWRLOCK;
        break;

    default:
        return EBADARG;
    }
    if (ivblock (psvbptr->iindexhandle, toffset, (off_t)1, ilocktype)) {
        return EFLOCKED;
    }
    if (imode == 2) {
        if (ivbblockread (ihandle, 1, (off_t) 1, cvbnodetmp)) {
            (void)ivblock (psvbptr->iindexhandle, toffset, (off_t)1, VBUNLOCK);
            return EBADFILE;
        }
        memcpy ((void *)&psvbptr->sdictnode, (void *)cvbnodetmp,
            sizeof (struct DICTNODE));
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbforcedataallocate	(	const int	ihandle,
		const off_t	trownumber
	)

Definition at line 355 of file vbindexio.c.

References DICTNODE::cdatacount, DICTNODE::cdatafree, cvbnodetmp, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, iserrno, ivbblockread(), ivbblockwrite(), ivbdatafree(), ivbnodefree(), psvbfile, QUADSIZE, and DICTINFO::sdictnode.

Referenced by ircvinsert(), and ivbrollmeback().

{
    struct DICTINFO *psvbptr;
    off_t       theadnode, tprevnode, tnextnode;
    int     iloop, ilengthused;

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

    /* Test 1: Is it already beyond EOF (the SIMPLE test) */
    theadnode = inl_ldquad (psvbptr->sdictnode.cdatacount);
    if (theadnode < trownumber) {
        psvbptr->iisdictlocked |= 0x02;
        inl_stquad (trownumber, psvbptr->sdictnode.cdatacount);
        theadnode++;
        while (theadnode < trownumber) {
            if (theadnode != 0) {
                ivbdatafree (ihandle, theadnode);
            }
            theadnode++;
        }
        return 0;
    }
    /* <SIGH> It SHOULD be *SOMEWHERE* in the data free list! */
    tprevnode = 0;
    theadnode = inl_ldquad (psvbptr->sdictnode.cdatafree);
    while (theadnode != 0) {
        iserrno = ivbblockread (ihandle, 1, theadnode, cvbnodetmp);
        if (iserrno) {
            return -1;
        }
        iserrno = EBADFILE;
/* C-ISAM is not 100% C-ISAM compatible */
#if ISAMMODE == 1
        if (cvbnodetmp[psvbptr->inodesize - 2] != 0x7f) {
            return -1;
        }
#endif
        if (cvbnodetmp[psvbptr->inodesize - 3] != -1) {
            return -1;
        }
        ilengthused = inl_ldint (cvbnodetmp);
        for (iloop = INTSIZE + QUADSIZE; iloop < ilengthused; iloop += QUADSIZE) {
            if (inl_ldquad (&cvbnodetmp[iloop]) == trownumber) {    /* Extract it */
                memcpy (&(cvbnodetmp[iloop]), &(cvbnodetmp[iloop + QUADSIZE]),
                    (size_t)(ilengthused - iloop));
                ilengthused -= QUADSIZE;
                if (ilengthused > INTSIZE + QUADSIZE) {
                    inl_stquad ((off_t)0, &cvbnodetmp[ilengthused]);
                    inl_stint (ilengthused, cvbnodetmp);
                    return ivbblockwrite (ihandle, 1, theadnode, cvbnodetmp);
                } else {    /* It was the last one in the node! */
                    tnextnode = inl_ldquad (&cvbnodetmp[INTSIZE]);
                    if (tprevnode) {
                        iserrno =
                            ivbblockread (ihandle, 1, tprevnode,
                                  cvbnodetmp);
                        if (iserrno) {
                            return -1;
                        }
                        inl_stquad (tnextnode, &cvbnodetmp[INTSIZE]);
                        return ivbblockwrite
                            (ihandle, 1, tprevnode, cvbnodetmp);
                    } else {
                        psvbptr->iisdictlocked |= 0x02;
                        inl_stquad (tnextnode,
                                psvbptr->sdictnode.cdatafree);
                    }
                    return ivbnodefree (ihandle, theadnode);
                }
            }
        }
        tprevnode = theadnode;
        theadnode = inl_ldquad (&cvbnodetmp[INTSIZE]);
    }
    /* If we get here, we've got a MAJOR integrity error in that the */
    /* nominated row number was simply *NOT FREE* */
    iserrno = EBADFILE;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbforceexit

(

const int

ihandle

)

Definition at line 50 of file isopen.c.

References cvbnodetmp, DICTINFO::iisdictlocked, iserrno, ivbblockwrite(), psvbfile, DICTINFO::sdictnode, and VB_NODE_MAX.

Referenced by isclose().

{
    struct DICTINFO *psvbptr;
    int     iresult = 0;
    char        cvbnodetmp[VB_NODE_MAX];

    psvbptr = psvbfile[ihandle];
    if (psvbptr->iisdictlocked & 0x02) {
        memset (cvbnodetmp, 0, VB_NODE_MAX);
        memcpy ((void *)cvbnodetmp, (void *)&psvbptr->sdictnode,
            sizeof (struct DICTNODE));
        iresult = ivbblockwrite (ihandle, 1, (off_t) 1, cvbnodetmp);
        if (iresult) {
            iserrno = EBADFILE;
        } else {
            iserrno = 0;
        }
    }
    psvbptr->iisdictlocked = 0;
    if (iresult) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeycompare	(	const int	ihandle,
		const int	ikeynumber,
		int	ilength,
		unsigned char *	pckey1,
		unsigned char *	pckey2
	)

Definition at line 230 of file vbkeysio.c.

References inl_ldint(), inl_ldlong(), inl_ldquad(), lddbl(), ldfloat(), DICTINFO::pskeydesc, psvbfile, and QUADSIZE.

Referenced by ichecktree(), itreeload(), and ivbkeylocaterow().

{
    struct keydesc  *pskeydesc;
    struct keypart  *pskptr;
    off_t       tvalue1, tvalue2;
    int     idescbias, ipart, ilengthtocompare;
    int     ivalue1, ivalue2;
    int     n;
    int     lvalue1, lvalue2;
    float       fvalue1, fvalue2;
    double      dvalue1, dvalue2;

    pskeydesc = psvbfile[ihandle]->pskeydesc[ikeynumber];
    if (ilength == 0) {
        ilength = pskeydesc->k_len;
    }
    for (ipart = 0; ilength > 0 && ipart < pskeydesc->k_nparts; ipart++) {
        pskptr = &pskeydesc->k_part[ipart];
        if (ilength >= pskptr->kp_leng) {
            ilengthtocompare = pskptr->kp_leng;
        } else {
            ilengthtocompare = ilength;
        }
        ilength -= ilengthtocompare;
        if (pskptr->kp_type & ISDESC) {
            idescbias = -1;
        } else {
            idescbias = 1;
        }
        switch (pskptr->kp_type & ~ISDESC) {
        case CHARTYPE:

            n = memcmp (pckey1, pckey2, (size_t)ilengthtocompare);
            if (n < 0) {
                return -idescbias;
            }
            if (n > 0) {
                return idescbias;
            }
            pckey1 += ilengthtocompare;
            pckey2 += ilengthtocompare;
/*
            while (ilengthtocompare--) {
                if (*pckey1 < *pckey2) {
                    return -idescbias;
                }
                if (*pckey1++ > *pckey2++) {
                    return idescbias;
                }
            }
*/
            break;

        case INTTYPE:
            while (ilengthtocompare >= INTSIZE) {
                ivalue1 = inl_ldint (pckey1);
                ivalue2 = inl_ldint (pckey2);
                if (ivalue1 < ivalue2) {
                    return -idescbias;
                }
                if (ivalue1 > ivalue2) {
                    return idescbias;
                }
                pckey1 += INTSIZE;
                pckey2 += INTSIZE;
                ilengthtocompare -= INTSIZE;
            }
            break;

        case LONGTYPE:
            while (ilengthtocompare >= LONGSIZE) {
                lvalue1 = inl_ldlong (pckey1);
                lvalue2 = inl_ldlong (pckey2);
                if (lvalue1 < lvalue2) {
                    return -idescbias;
                }
                if (lvalue1 > lvalue2) {
                    return idescbias;
                }
                pckey1 += LONGSIZE;
                pckey2 += LONGSIZE;
                ilengthtocompare -= LONGSIZE;
            }
            break;

        case QUADTYPE:
            while (ilengthtocompare >= QUADSIZE) {
                tvalue1 = inl_ldquad (pckey1);
                tvalue2 = inl_ldquad (pckey2);
                if (tvalue1 < tvalue2) {
                    return -idescbias;
                }
                if (tvalue1 > tvalue2) {
                    return idescbias;
                }
                pckey1 += QUADSIZE;
                pckey2 += QUADSIZE;
                ilengthtocompare -= QUADSIZE;
            }
            break;

        case FLOATTYPE:
            while (ilengthtocompare >= FLOATSIZE) {
                fvalue1 = ldfloat (pckey1);
                fvalue2 = ldfloat (pckey2);
                if (fvalue1 < fvalue2) {
                    return -idescbias;
                }
                if (fvalue1 > fvalue2) {
                    return idescbias;
                }
                pckey1 += FLOATSIZE;
                pckey2 += FLOATSIZE;
                ilengthtocompare -= FLOATSIZE;
            }
            break;

        case DOUBLETYPE:
            while (ilengthtocompare >= DOUBLESIZE) {
                dvalue1 = lddbl (pckey1);
                dvalue2 = lddbl (pckey2);
                if (dvalue1 < dvalue2) {
                    return -idescbias;
                }
                if (dvalue1 > dvalue2) {
                    return idescbias;
                }
                pckey1 += DOUBLESIZE;
                pckey2 += DOUBLESIZE;
                ilengthtocompare -= DOUBLESIZE;
            }
            break;

        default:
            break;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeydelete	(	const int	ihandle,
		const int	ikeynumber
	)

Definition at line 777 of file vbkeysio.c.

References VBKEY::iisdummy, VBTREE::iiseof, VBKEY::iishigh, VBTREE::iisroot, VBTREE::iistof, VBTREE::ikeysinnode, VBTREE::ilevel, ivbnodefree(), ivbnodeload(), ivbnodesave(), NULL, VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeycurr, DICTINFO::pskeydesc, VBTREE::pskeyfirst, VBTREE::pskeylist, VBKEY::psnext, VBKEY::psparent, VBTREE::psparent, VBKEY::psprev, DICTINFO::pstree, psvbfile, VBKEY::tdupnumber, VBTREE::tnodenumber, VBKEY::trownode, vvbkeyfree(), and vvbtreeallfree().

Referenced by irowdelete(), and irowupdate().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey, *pskeytemp;
    struct VBTREE   *pstree, *pstreeroot;
    int     iforcerewrite = 0, iposn, iresult;

    psvbptr = psvbfile[ihandle];
    pskey = psvbptr->pskeycurr[ikeynumber];
    /*
     * We're going to *TRY* to keep the index buffer populated!
     * However, since it's technically feasible for the current node to be
     * removed in it's entirety, we can only do this if there is at least 1
     * other key in the node that's not the dummy entry.
     * Since the current key is guaranteed to be at the LEAF node level (0),
     * it's impossible to ever have an iishigh entry in the node.
     */
    if (pskey->psnext && pskey->psnext->iisdummy == 0) {
        psvbptr->pskeycurr[ikeynumber] = pskey->psnext;
        pskey->psparent->pskeycurr = pskey->psnext;
    } else {
        if (pskey->psprev) {
            psvbptr->pskeycurr[ikeynumber] = pskey->psprev;
            pskey->psparent->pskeycurr = pskey->psprev;
        } else {
            psvbptr->pskeycurr[ikeynumber] = NULL;
            pskey->psparent->pskeycurr = NULL;
        }
    }
    while (1) {
        pstree = pskey->psparent;
        if (pskey->iishigh) {
            /*
             * Handle removal of the high key in a node.
             * Since we're modifying a key OTHER than the one we're
             * deleting, we need a FULL node rewrite!
             */
            if (pskey->psprev) {
                pskey->pschild = pskey->psprev->pschild;
                pskey->trownode = pskey->psprev->trownode;
                pskey->tdupnumber = pskey->psprev->tdupnumber;
                pskey = pskey->psprev;
                iforcerewrite = 1;
            } else {
                iresult = ivbnodefree (ihandle, pstree->tnodenumber);   /* BUG - didn't check iresult */
                pstree = pstree->psparent;
                vvbtreeallfree (ihandle, ikeynumber,
                        pstree->pskeycurr->pschild);
                pskey = pstree->pskeycurr;
                pskey->pschild = NULL;
                continue;
            }
        }
        iposn = -1;
        pskey->psparent->ikeysinnode = 0;
        for (pskeytemp = pskey->psparent->pskeyfirst; pskeytemp;
             pskeytemp = pskeytemp->psnext) {
            if (pskey == pskeytemp) {
                iposn = pskey->psparent->ikeysinnode;
            } else {
                pskey->psparent->pskeylist[pskey->psparent->ikeysinnode] = pskeytemp;
                pskey->psparent->ikeysinnode++;
            }
        }
        if (pskey->psprev) {
            pskey->psprev->psnext = pskey->psnext;
        } else {
            pstree->pskeyfirst = pskey->psnext;
        }
        if (pskey->psnext) {
            pskey->psnext->psprev = pskey->psprev;
        }
        pskey->psparent = NULL;
        pskey->pschild = NULL;
        vvbkeyfree (ihandle, ikeynumber, pskey);
        if (pstree->iisroot
            && (pstree->pskeyfirst->iishigh
            || pstree->pskeyfirst->iisdummy)) {
            pskey = pstree->pskeyfirst;
            if (!pskey->pschild) {
                pstreeroot = pstree;
            } else {
                pstreeroot = pskey->pschild;
                pskey->pschild = NULL;
            }
            if (pskey->iisdummy) {  /* EMPTY FILE! */
                return ivbnodesave (ihandle, ikeynumber, pstreeroot,
                     pstreeroot->tnodenumber, 0, 0);
            }
            iresult = ivbnodeload (ihandle, ikeynumber, pstreeroot, pskey->trownode,
                     (int)pstree->ilevel);
            if (iresult) {
                return iresult; /* BUG Corrupt! */
            }
            iresult = ivbnodefree (ihandle, pstreeroot->tnodenumber);
            if (iresult) {
                return iresult; /* BUG Corrupt! */
            }
            pstreeroot->tnodenumber =
                psvbptr->pskeydesc[ikeynumber]->k_rootnode;
            pstreeroot->psparent = NULL;
            pstreeroot->iistof = 1;
            pstreeroot->iiseof = 1;
            pstreeroot->iisroot = 1;
            if (pstree != pstreeroot) {
                vvbtreeallfree (ihandle, ikeynumber, pstree);
            }
            psvbptr->pstree[ikeynumber] = pstreeroot;
            return ivbnodesave (ihandle, ikeynumber, pstreeroot,
                pstreeroot->tnodenumber, 0, 0);
        }
        if (pstree->pskeyfirst->iisdummy) {
            /* Handle removal of the last key in a node */
            iresult = ivbnodefree (ihandle, pstree->tnodenumber);
            if (iresult) {
                return iresult; /* BUG Corrupt! */
            }
            pstree = pstree->psparent;
            vvbtreeallfree (ihandle, ikeynumber, pstree->pskeycurr->pschild);
            pstree->pskeycurr->pschild = NULL;
            pskey = pstree->pskeycurr;
            continue;
        }
        break;
    }
    if (iforcerewrite) {
        return ivbnodesave (ihandle, ikeynumber, pstree, pstree->tnodenumber, 0, 0);
    }
    return ivbnodesave (ihandle, ikeynumber, pstree, pstree->tnodenumber, -1, iposn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeyinsert	(	const int	ihandle,
		struct VBTREE *	pstree,
		const int	ikeynumber,
		unsigned char *	pckeyvalue,
		off_t	trownode,
		off_t	tdupnumber,
		struct VBTREE *	pschild
	)

Definition at line 727 of file vbkeysio.c.

References VBKEY::ckey, VBKEY::iisnew, VBTREE::ikeysinnode, ivbnodesave(), VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeycurr, DICTINFO::pskeydesc, VBTREE::pskeyfirst, VBTREE::pskeylist, VBKEY::psnext, VBKEY::psparent, VBKEY::psprev, psvbfile, psvbkeyallocate(), VBKEY::tdupnumber, VBTREE::tnodenumber, and VBKEY::trownode.

Referenced by imakekeysfromdata(), inodesplit(), irowinsert(), irowupdate(), and vaddkeyforrow().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey, *pstempkey;
    int     iposn = 0, iresult;

    psvbptr = psvbfile[ihandle];
    pskey = psvbkeyallocate (ihandle, ikeynumber);
    if (!pskey) {
        return errno;
    }
    if (!psvbptr->pskeycurr[ikeynumber]) {
        return EBADFILE;
    }
    if (!pstree) {
        pstree = psvbptr->pskeycurr[ikeynumber]->psparent;
    }
    pskey->psparent = pstree;
    pskey->pschild = pschild;
    pskey->trownode = trownode;
    pskey->tdupnumber = tdupnumber;
    pskey->iisnew = 1;
    memcpy (pskey->ckey, pckeyvalue, (size_t)psvbptr->pskeydesc[ikeynumber]->k_len);
    pskey->psnext = pstree->pskeycurr;
    pskey->psprev = pstree->pskeycurr->psprev;
    if (pstree->pskeycurr->psprev) {
        pstree->pskeycurr->psprev->psnext = pskey;
    } else {
        pstree->pskeyfirst = pskey;
    }
    pstree->pskeycurr->psprev = pskey;
    pstree->pskeycurr = pskey;
    psvbptr->pskeycurr[ikeynumber] = pskey;
    pstree->ikeysinnode = 0;
    for (pstempkey = pstree->pskeyfirst; pstempkey; pstempkey = pstempkey->psnext) {
        if (pstempkey == pskey) {
            iposn = pstree->ikeysinnode;
        }
        pstree->pskeylist[pstree->ikeysinnode] = pstempkey;
        pstree->ikeysinnode++;
    }
    iresult = ivbnodesave (ihandle, ikeynumber, pskey->psparent,
            pskey->psparent->tnodenumber, 1, iposn);
    pskey->iisnew = 0;
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeyload	(	const int	ihandle,
		const int	ikeynumber,
		const int	imode,
		const int	isetcurr,
		struct VBKEY **	ppskey
	)

Definition at line 503 of file vbkeysio.c.

References DICTINFO::iindexchanged, VBKEY::iisdummy, VBTREE::iiseof, VBTREE::iistof, VBTREE::ilevel, ivbnodeload(), NULL, VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeycurr, VBTREE::pskeyfirst, VBTREE::pskeylast, VBKEY::psnext, VBKEY::psparent, VBTREE::psparent, VBKEY::psprev, psvbfile, psvbtreeallocate(), VBKEY::trownode, and vvbtreeallfree().

Referenced by imakekeysfromdata(), irowinsert(), irowupdate(), isread(), isstart(), ivbkeylocaterow(), ivbkeysearch(), and vaddkeyforrow().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey, *pskeyhold;
    struct VBTREE   *pstree;
    int     iresult;

    psvbptr = psvbfile[ihandle];
    pskey = psvbptr->pskeycurr[ikeynumber];
    if (pskey->psparent->ilevel) {
        return EBADFILE;
    }
    switch (imode) {
    case ISPREV:
        if (pskey->psprev) {
            *ppskey = pskey->psprev;
            if (isetcurr) {
                psvbptr->pskeycurr[ikeynumber] = pskey->psprev;
                pskey->psparent->pskeycurr = pskey->psprev;
            }
            return 0;
        }
        pstree = pskey->psparent;
        if (pstree->iistof) {
            return EENDFILE;
        }
        /* Back up the tree until we find a node where there is a < */
        while (pstree->pskeycurr == pstree->pskeyfirst) {
            if (pstree->psparent) {
                pstree = pstree->psparent;
            } else {
                break;
            }
        }
        /* Back down the tree selecting the LAST valid key of each */
        pskey = pstree->pskeycurr->psprev;
        if (isetcurr) {
            pstree->pskeycurr = pstree->pskeycurr->psprev;
        }
        while (pstree->ilevel && pskey) {
            if (isetcurr) {
                pstree->pskeycurr = pskey;
            }
            if (!pskey->pschild || psvbptr->iindexchanged) {
                if (!pskey->pschild) {
                    pskey->pschild = psvbtreeallocate (ihandle);
                    if (!pskey->pschild) {
                        return errno;
                    }
                    pskey->pschild->psparent = pskey->psparent;
                    if (pskey->psparent->iistof
                        && pskey == pskey->psparent->pskeyfirst) {
                        pskey->pschild->iistof = 1;
                    }
                    if (pskey->psparent->iiseof
                        && pskey == pskey->psparent->pskeylast->psprev) {
                        pskey->pschild->iiseof = 1;
                    }
                }
                pskeyhold = pskey;
                iresult = ivbnodeload (ihandle, ikeynumber, pskey->pschild,
                         pskey->trownode, (int)pstree->ilevel);
                if (iresult) {
                    /* Ooops, make sure the tree is not corrupt */
                    vvbtreeallfree (ihandle, ikeynumber,
                            pskeyhold->pschild);
                    pskeyhold->pschild = NULL;
                    return iresult;
                }
            }
            pstree = pskey->pschild;
            /* Last key is always the dummy, so backup by one */
            pskey = pstree->pskeylast->psprev;
        }
        if (isetcurr) {
            pstree->pskeycurr = pskey;
            psvbptr->pskeycurr[ikeynumber] = pskey;
        }
        *ppskey = pskey;
        break;

    case ISNEXT:
        if (pskey->psnext && !pskey->psnext->iisdummy) {
            *ppskey = pskey->psnext;
            if (isetcurr) {
                psvbptr->pskeycurr[ikeynumber] = pskey->psnext;
                pskey->psparent->pskeycurr = pskey->psnext;
            }
            return 0;
        }
        pstree = pskey->psparent;
        if (pstree->iiseof) {
            return EENDFILE;
        }
        pstree = pstree->psparent;
        /* Back up the tree until we find a node where there is a > */
        while (1) {
            if (pstree->pskeylast->psprev != pstree->pskeycurr) {
                break;
            }
            pstree = pstree->psparent;
        }
        pskey = pstree->pskeycurr->psnext;
        if (isetcurr) {
            pstree->pskeycurr = pstree->pskeycurr->psnext;
        }
        /* Back down the tree selecting the FIRST valid key of each */
        while (pstree->ilevel) {
            if (isetcurr) {
                pstree->pskeycurr = pskey;
            }
            if (!pskey->pschild || psvbptr->iindexchanged) {
                if (!pskey->pschild) {
                    pskey->pschild = psvbtreeallocate (ihandle);
                    if (!pskey->pschild) {
                        return errno;
                    }
                    pskey->pschild->psparent = pskey->psparent;
                    if (pskey->psparent->iistof
                        && pskey == pskey->psparent->pskeyfirst) {
                        pskey->pschild->iistof = 1;
                    }
                    if (pskey->psparent->iiseof
                        && pskey == pskey->psparent->pskeylast->psprev) {
                        pskey->pschild->iiseof = 1;
                    }
                }
                pskeyhold = pskey;
                iresult = ivbnodeload (ihandle, ikeynumber, pskey->pschild,
                         pskey->trownode, (int)pstree->ilevel);
                if (iresult) {
                    /* Ooops, make sure the tree is not corrupt */
                    vvbtreeallfree (ihandle, ikeynumber,
                            pskeyhold->pschild);
                    pskeyhold->pschild = NULL;
                    return iresult;
                }
            }
            pstree = pskey->pschild;
            pskey = pstree->pskeyfirst;
        }
        if (isetcurr) {
            pstree->pskeycurr = pskey;
            psvbptr->pskeycurr[ikeynumber] = pskey;
        }
        *ppskey = pskey;
        break;

    default:
        break;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeylocaterow	(	const int	ihandle,
		const int	ikeynumber,
		off_t	trownumber
	)

Definition at line 435 of file vbkeysio.c.

References VBKEY::ckey, iserrno, ivbkeycompare(), ivbkeyload(), ivbkeysearch(), DICTINFO::ppcrowbuffer, VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeycurr, DICTINFO::pskeydesc, VBTREE::pskeyfirst, VBKEY::psnext, VBKEY::psparent, VBTREE::psparent, psvbfile, VBKEY::trownode, and vvbmakekey().

Referenced by irowdelete(), irowupdate(), and isread().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey;
    struct VBTREE   *pstree;
    int     iresult;
    unsigned char   ckeyvalue[VB_MAX_KEYLEN];

    /*
     * Step 1:
     *      The easy way out...
     *      If it is already the current index pointer *AND*
     *      the index file has remained unchanged since then,
     *      we don't need to do anything
     */
    psvbptr = psvbfile[ihandle];
    iresult = 1;
    pskey = psvbptr->pskeycurr[ikeynumber];
    if (pskey && pskey->trownode == trownumber) {
        pskey->psparent->pskeycurr = pskey;
        /* Position pskeycurr all the way up to the root to point at us */
        pstree = pskey->psparent;
        while (pstree->psparent) {
            for (pstree->psparent->pskeycurr = pstree->psparent->pskeyfirst;
                 pstree->psparent->pskeycurr
                 && pstree->psparent->pskeycurr->pschild != pstree;
                 pstree->psparent->pskeycurr =
                 pstree->psparent->pskeycurr->psnext) ;
            if (!pstree->psparent->pskeycurr) {
                iresult = 0;
            }
            pstree = pstree->psparent;
        }
        if (iresult) {
            return 0;
        }
    }

    /*
     * Step 2:
     *      It's a valid and non-deleted row.  Therefore, let's make a
     *      contiguous key from it to search by.
     *      Find the damn key!
     */
    vvbmakekey (psvbptr->pskeydesc[ikeynumber], psvbptr->ppcrowbuffer, ckeyvalue);
    iresult = ivbkeysearch (ihandle, ISGTEQ, ikeynumber, 0, ckeyvalue, (off_t)0);
    if (iresult < 0 || iresult > 1) {
        iserrno = ENOREC;
        return -1;
    }
    while (psvbptr->pskeycurr[ikeynumber]->trownode != trownumber) {
        iserrno = ivbkeyload (ihandle, ikeynumber, ISNEXT, 1, &pskey);
        if (iserrno) {
            if (iserrno == EENDFILE) {
                iserrno = ENOREC;
            }
            return -1;
        }
        if (ivbkeycompare (ihandle, ikeynumber, 0, ckeyvalue,
             psvbptr->pskeycurr[ikeynumber]->ckey)) {
            iserrno = ENOREC;
            return -1;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbkeysearch	(	const int	ihandle,
		const int	imode,
		const int	ikeynumber,
		int	ilength,
		unsigned char *	pckeyvalue,
		off_t	tdupnumber
	)

Definition at line 372 of file vbkeysio.c.

References iserrno, itreeload(), ivbkeyload(), DICTINFO::pskeydesc, psvbfile, VB_MAX_OFF_T, and vvbkeyvalueset().

Referenced by imakekeysfromdata(), irowinsert(), irowupdate(), isdelete(), isread(), isrewrite(), isstart(), ivbkeylocaterow(), and vaddkeyforrow().

{
    struct VBKEY    *pskey;
    struct keydesc  *pskeydesc;
    int     iresult;
    unsigned char   ckeyvalue[VB_MAX_KEYLEN];

    pskeydesc = psvbfile[ihandle]->pskeydesc[ikeynumber];
    if (ilength == 0) {
        ilength = pskeydesc->k_len;
    }
    switch (imode) {
    case ISFIRST:
        vvbkeyvalueset (0, pskeydesc, ckeyvalue);
        tdupnumber = -1;
        return itreeload (ihandle, ikeynumber, ilength, ckeyvalue, tdupnumber);

    case ISLAST:
        vvbkeyvalueset (1, pskeydesc, ckeyvalue);
        tdupnumber = VB_MAX_OFF_T;
        return itreeload (ihandle, ikeynumber, ilength, ckeyvalue, tdupnumber);

    case ISNEXT:
        iresult = ivbkeyload (ihandle, ikeynumber, ISNEXT, 1, &pskey);
        iserrno = iresult;
        if (iresult == EENDFILE) {
            iresult = 0;
        }
        if (iresult) {
            return -1;
        }
        return 1;   /* "NEXT" can NEVER be an exact match! */

    case ISPREV:
        iresult = ivbkeyload (ihandle, ikeynumber, ISPREV, 1, &pskey);
        iserrno = iresult;
        if (iresult == EENDFILE) {
            iresult = 0;
        }
        if (iresult) {
            return -1;
        }
        return 1;   /* "PREV" can NEVER be an exact match */

    case ISCURR:
        return itreeload (ihandle, ikeynumber, ilength, pckeyvalue, tdupnumber);

    case ISEQUAL:       /* Falls thru to ISGTEQ */
        tdupnumber = 0;
    case ISGTEQ:
        return itreeload (ihandle, ikeynumber, ilength, pckeyvalue, tdupnumber);

    case ISGREAT:
        tdupnumber = VB_MAX_OFF_T;
        return itreeload (ihandle, ikeynumber, ilength, pckeyvalue, tdupnumber);

    }
    /* From call sites, not possible */
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivblock	(	const int	ihandle,
		const off_t	toffset,
		const off_t	tlength,
		const int	imode
	)

Definition at line 197 of file vblowlevel.c.

References svbfile, VBRDLCKW, VBRDLOCK, VBUNLOCK, VBWRLCKW, and VBWRLOCK.

Referenced by ivbdatalock(), ivbenter(), ivbexit(), ivbfileopenlock(), and iwritetrans().

{
#ifdef  _WIN32
#ifdef  USE_LOCKFILE_EX

    OVERLAPPED  toverlapped;
    DWORD       tflags = 0;
    DWORD       winerrno = 0;
    int     bunlock = 0;

    if (!svbfile[ihandle].irefcount) {
        errno = ENOENT;
        return -1;
    }

    switch (imode) {
    case    VBUNLOCK:
        bunlock = 1;
        break;

    case    VBRDLOCK:
        tflags = LOCKFILE_FAIL_IMMEDIATELY;
        break;

    case    VBRDLCKW:
        tflags = 0;
        break;

    case    VBWRLOCK:
        tflags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY;
        break;

    case    VBWRLCKW:
        tflags = LOCKFILE_EXCLUSIVE_LOCK;
        break;

    default:
        errno = EBADARG;
        return -1;
    }

    memset (&toverlapped, 0, sizeof(OVERLAPPED));
    toverlapped.Offset = (DWORD)(toffset & 0xffffffff);
    toverlapped.OffsetHigh = (DWORD)(toffset >> 32);
    errno = 0;
    if (!bunlock) {
        if (LockFileEx (svbfile[ihandle].whandle, tflags, 0, (int)(tlength & 0xffffffff),
            (int)(tlength >> 32), &toverlapped)) {
            return 0;
        }
    } else {
        if (UnlockFileEx (svbfile[ihandle].whandle, 0, (int)(tlength & 0xffffffff),
            (int)(tlength >> 32), &toverlapped)) {
            return 0;
        }
        winerrno = GetLastError ();
        if (winerrno == ERROR_NOT_LOCKED) {
            //ALREADY UNLOCKED **SAME FCNTL**
            return 0;
        }
    }

    errno = EBADARG;
    return -1;
#else
/* This will probably not work correctly - 64 bit */
    int     itype, iresult = -1;
    off_t       soffset;
    off_t       tempoffset;

    if (!svbfile[ihandle].irefcount) {
        errno = ENOENT;
        return -1;
    }
    switch (imode) {
    case VBUNLOCK:
        itype = _LK_UNLCK;
        break;

    case VBRDLOCK:
        itype = _LK_NBRLCK;
        break;

    case VBRDLCKW:
        itype = _LK_RLCK;
        break;

    case VBWRLOCK:
        itype = _LK_NBLCK;
        break;

    case VBWRLCKW:
        itype = _LK_LOCK;
        break;

    default:
        errno = EBADARG;
        return -1;
    }
    soffset = lseek (svbfile[ihandle].ihandle, 0, SEEK_CUR);
    if (soffset == -1) {
        errno = 172;
        return -1;
    }
    tempoffset = lseek (svbfile[ihandle].ihandle, toffset, SEEK_SET);
    if (tempoffset == -1) {
        errno = 172;
        return -1;
    }
    errno = 0;
    iresult = _locking (svbfile[ihandle].ihandle, itype, (long)tlength);
    /* Something weird going on here */
    if (errno == 22) {
        errno = 0;
        iresult = 0;
    }
    lseek (svbfile[ihandle].ihandle, soffset, SEEK_SET);
    return iresult;
#endif
#else
    int     icommand, itype, iresult;
    struct flock    sflock;

    if (!svbfile[ihandle].irefcount) {
        errno = ENOENT;
        return -1;
    }
    switch (imode) {
    case VBUNLOCK:
        icommand = F_SETLK;
        itype = F_UNLCK;
        break;

    case VBRDLOCK:
        icommand = F_SETLK;
        itype = F_RDLCK;
        break;

    case VBRDLCKW:
        icommand = F_SETLKW;
        itype = F_RDLCK;
        break;

    case VBWRLOCK:
        icommand = F_SETLK;
        itype = F_WRLCK;
        break;

    case VBWRLCKW:
        icommand = F_SETLKW;
        itype = F_WRLCK;
        break;

    default:
        errno = EBADARG;
        return -1;
    }
    sflock.l_type = itype;
    sflock.l_whence = SEEK_SET;
    sflock.l_start = toffset;
    sflock.l_len = tlength;
    sflock.l_pid = 0;
    do {
        iresult = fcntl (svbfile[ihandle].ihandle, icommand, &sflock);
    } while (iresult && errno == EINTR);

    return iresult;
#endif
}

Here is the caller graph for this function:

int ivbnodefree	(	const int	ihandle,
		const off_t	tnodenumber
	)

Definition at line 67 of file vbindexio.c.

References DICTNODE::cnodefree, cvbnodetmp, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, iserrno, ivbblockread(), ivbblockwrite(), psvbfile, QUADSIZE, DICTINFO::sdictnode, and VB_NODE_MAX.

Referenced by idelnodes(), ivbforcedataallocate(), ivbkeydelete(), ivbvarlendelete(), tvbdataallocate(), and vrebuildindexfree().

{
    struct DICTINFO *psvbptr;
    off_t       theadnode;
    int     ilengthused, iresult;
    char        cvbnodetmp2[VB_NODE_MAX];

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

    memset (cvbnodetmp2, 0, (size_t) psvbptr->inodesize);
    inl_stint (INTSIZE, cvbnodetmp2);

    theadnode = inl_ldquad (psvbptr->sdictnode.cnodefree);
    /* If the list is empty, node tnodenumber becomes the whole list */
    if (theadnode == 0) {
        inl_stint (INTSIZE + QUADSIZE, cvbnodetmp2);
        inl_stquad ((off_t)0, cvbnodetmp2 + INTSIZE);
        cvbnodetmp2[psvbptr->inodesize - 2] = 0x7f;
        cvbnodetmp2[psvbptr->inodesize - 3] = -2;
        iresult = ivbblockwrite (ihandle, 1, tnodenumber, cvbnodetmp2);
        if (iresult) {
            return iresult;
        }
        inl_stquad (tnodenumber, psvbptr->sdictnode.cnodefree);
        psvbptr->iisdictlocked |= 0x02;
        return 0;
    }

    /* Read in the head of the current free list */
    iresult = ivbblockread (ihandle, 1, theadnode, cvbnodetmp);
    if (iresult) {
        return iresult;
    }
/* C-ISAM is not 100% C-ISAM compatible */
#if ISAMMODE == 1
    if (cvbnodetmp[psvbptr->inodesize - 2] != 0x7f) {
        return EBADFILE;
    }
#endif
    if (cvbnodetmp[psvbptr->inodesize - 3] != -2) {
        return EBADFILE;
    }
    ilengthused = inl_ldint (cvbnodetmp);
    if (ilengthused >= psvbptr->inodesize - (QUADSIZE + 3)) {
        /* If there was no space left, tnodenumber becomes the head */
        cvbnodetmp2[psvbptr->inodesize - 2] = 0x7f;
        cvbnodetmp2[psvbptr->inodesize - 3] = -2;
        inl_stint (INTSIZE + QUADSIZE, cvbnodetmp2);
        inl_stquad (theadnode, &cvbnodetmp2[INTSIZE]);
        iresult = ivbblockwrite (ihandle, 1, tnodenumber, cvbnodetmp2);
        if (!iresult) {
            inl_stquad (tnodenumber, psvbptr->sdictnode.cnodefree);
            psvbptr->iisdictlocked |= 0x02;
        }
        return iresult;
    }

    /* If we got here, there's space left in the theadnode to store it */
    cvbnodetmp2[psvbptr->inodesize - 2] = 0x7f;
    cvbnodetmp2[psvbptr->inodesize - 3] = -2;
    iresult = ivbblockwrite (ihandle, 1, tnodenumber, cvbnodetmp2);
    if (iresult) {
        return iresult;
    }
    inl_stquad (tnodenumber, &cvbnodetmp[ilengthused]);
    ilengthused += QUADSIZE;
    inl_stint (ilengthused, cvbnodetmp);
    iresult = ivbblockwrite (ihandle, 1, theadnode, cvbnodetmp);

    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbnodeload	(	const int	ihandle,
		const int	ikeynumber,
		struct VBTREE *	pstree,
		const off_t	tnodenumber,
		const int	iprevlvl
	)

Definition at line 285 of file vbnodememio.c.

References VBKEY::ckey, cvbnodetmp, VBKEY::iisdummy, VBKEY::iishigh, VBTREE::ikeysinnode, VBTREE::ilevel, inl_ldint(), inl_ldquad(), DICTINFO::inodesize, ivbblockread(), NULL, VBKEY::pschild, VBTREE::pskeycurr, DICTINFO::pskeydesc, VBTREE::pskeyfirst, VBTREE::pskeylast, VBTREE::pskeylist, VBKEY::psnext, VBKEY::psparent, VBKEY::psprev, psvbfile, psvbkeyallocate(), QUADSIZE, TCC, VBKEY::tdupnumber, VBTREE::tnodenumber, VBKEY::trownode, VBTREE::ttransnumber, vvbkeyfree(), vvbkeyvalueset(), and vvbtreeallfree().

Referenced by ichecktree(), itreeload(), ivbkeydelete(), and ivbkeyload().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskey, *pskeynext;
    struct keydesc  *pskeydesc;
    char        *pcnodeptr;
#if ISAMMODE == 1
    off_t       ttransnumber;
#endif
    int     icountlc = 0;   /* Leading compression */
    int     icounttc = 0;   /* Trailing compression */
    int     idups = 0, inodelen, iresult;
    unsigned char   cprevkey[VB_MAX_KEYLEN];
    unsigned char   chighkey[VB_MAX_KEYLEN];

    psvbptr = psvbfile[ihandle];
    pskeydesc = psvbptr->pskeydesc[ikeynumber];
    vvbkeyvalueset (0, pskeydesc, cprevkey);
    vvbkeyvalueset (1, pskeydesc, chighkey);
    iresult = ivbblockread (ihandle, 1, tnodenumber, cvbnodetmp);
    if (iresult) {
        return iresult;
    }
    if (iprevlvl != -1) {
        if (*(cvbnodetmp + psvbptr->inodesize - 2) != iprevlvl - 1) {
            return EBADFILE;
        }
    }
    pstree->tnodenumber = tnodenumber;
    pstree->ilevel = *(cvbnodetmp + psvbptr->inodesize - 2);
    inodelen = inl_ldint (cvbnodetmp);
#if ISAMMODE == 1
    pcnodeptr = cvbnodetmp + INTSIZE + QUADSIZE;
    ttransnumber = inl_ldquad (cvbnodetmp + INTSIZE);
    if (ttransnumber == pstree->ttransnumber) {
        return 0;
    }
#else
    pcnodeptr = cvbnodetmp + INTSIZE;
#endif
    for (pskey = pstree->pskeyfirst; pskey; pskey = pskeynext) {
        if (pskey->pschild) {
            vvbtreeallfree (ihandle, ikeynumber, pskey->pschild);
        }
        pskey->pschild = NULL;
        pskeynext = pskey->psnext;
        vvbkeyfree (ihandle, ikeynumber, pskey);
    }
    pstree->pskeyfirst = pstree->pskeycurr = pstree->pskeylast = NULL;
    pstree->ikeysinnode = 0;
    while (pcnodeptr - cvbnodetmp < inodelen) {
        pskey = psvbkeyallocate (ihandle, ikeynumber);
        if (!pskey) {
            return errno;
        }
        if (!idups) {
            if (pskeydesc->k_flags & LCOMPRESS) {
#if ISAMMODE == 1
                icountlc = inl_ldint (pcnodeptr);
                pcnodeptr += INTSIZE;
#else
                icountlc = *(pcnodeptr);
                pcnodeptr++;
#endif
            }
            if (pskeydesc->k_flags & TCOMPRESS) {
#if ISAMMODE == 1
                icounttc = inl_ldint (pcnodeptr);
                pcnodeptr += INTSIZE;
#else
                icounttc = *(pcnodeptr);
                pcnodeptr++;
#endif
            }
            memcpy (cprevkey + icountlc, pcnodeptr,
                (size_t)(pskeydesc->k_len - (icountlc + icounttc)));
            memset (cprevkey + pskeydesc->k_len - icounttc, TCC, (size_t)icounttc);
            pcnodeptr += pskeydesc->k_len - (icountlc + icounttc);
        }
        if (pskeydesc->k_flags & ISDUPS) {
            pskey->tdupnumber = inl_ldquad (pcnodeptr);
            pcnodeptr += QUADSIZE;
        } else {
            pskey->tdupnumber = 0;
        }
        if (pskeydesc->k_flags & DCOMPRESS) {
            if (*pcnodeptr & 0x80) {
                idups = 1;
            } else {
                idups = 0;
            }
            *pcnodeptr &= ~0x80;
        }
        pskey->trownode = inl_ldquad (pcnodeptr);
        pcnodeptr += QUADSIZE;
        pskey->psparent = pstree;
        if (pstree->pskeyfirst) {
            pstree->pskeylast->psnext = pskey;
        } else {
            pstree->pskeyfirst = pstree->pskeycurr = pskey;
        }
        pstree->pskeylist[pstree->ikeysinnode] = pskey;
        pstree->ikeysinnode++;
        pskey->psprev = pstree->pskeylast;
        pstree->pskeylast = pskey;
        memcpy (pskey->ckey, cprevkey, (size_t)pskeydesc->k_len);
    }
    if (pstree->ilevel) {
        pstree->pskeylast->iishigh = 1;
        memcpy (pstree->pskeylast->ckey, chighkey, (size_t)pskeydesc->k_len);
    }
    pskey = psvbkeyallocate (ihandle, ikeynumber);
    if (!pskey) {
        return errno;
    }
    pskey->psparent = pstree;
    pskey->iisdummy = 1;
    if (pstree->pskeyfirst) {
        pstree->pskeylast->psnext = pskey;
    } else {
        pstree->pskeyfirst = pstree->pskeycurr = pskey;
    }
    pskey->psprev = pstree->pskeylast;
    pstree->pskeylast = pskey;
    pstree->pskeylist[pstree->ikeysinnode] = pskey;
    pstree->ikeysinnode++;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbnodesave	(	const int	ihandle,
		const int	ikeynumber,
		struct VBTREE *	pstree,
		const off_t	tnodenumber,
		const int	imode,
		const int	iposn
	)

Definition at line 416 of file vbnodememio.c.

References VBKEY::ckey, DICTNODE::ctransnumber, cvbnodetmp, VBKEY::iisdummy, VBKEY::iishigh, VBKEY::iisnew, VBTREE::ikeysinnode, VBTREE::ilevel, inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, inodesplit(), iquicknodesave(), ivbblockwrite(), NULL, DICTINFO::pskeydesc, VBTREE::pskeyfirst, VBTREE::pskeylast, VBTREE::pskeylist, VBKEY::psnext, VBKEY::psprev, psvbfile, QUADSIZE, DICTINFO::sdictnode, TCC, VBKEY::tdupnumber, VBKEY::trownode, and VB_NODE_MAX.

Referenced by inewroot(), inodesplit(), ivbkeydelete(), and ivbkeyinsert().

{
    struct DICTINFO *psvbptr;
    unsigned char   *pckeyendptr, *pcnodeptr, *pcnodehalfway;
    unsigned char   *pcnodeend, *pcprevkey = NULL;
    struct VBKEY    *pskey, *pskeyhalfway = NULL;
    struct keydesc  *pskeydesc;
    int     icountlc = 0,   /* Leading compression */
            icounttc = 0,   /* Trailing compression */
            ilasttc = 0, ikeylen, imaxtc, iresult;

    psvbptr = psvbfile[ihandle];
    pskeydesc = psvbptr->pskeydesc[ikeynumber];
    /*
     * If it's an INSERT into a node or a DELETE from a node
     *      *AND*
     * there's no compression
     *      *THEN*
     * We can *TRY* to do a quick and dirty insertion / deletion instead!
     * However, it's still possible that we have insufficient free space
     * so we *MAY* still need to continue.
     */
    if (pstree->ilevel) {
        if (pstree->pskeylast->psprev) {
            pstree->pskeylast->psprev->iishigh = 1;
        }
    }
    if (imode && !(pskeydesc->k_flags & (DCOMPRESS | TCOMPRESS | LCOMPRESS))) {
        if (iquicknodesave (ihandle, pstree, tnodenumber, pskeydesc, imode, iposn) == 0) {
            return 0;
        }
    }
    pcnodehalfway = (ucharptr)cvbnodetmp + (psvbptr->inodesize / 2);
    pcnodeend = (ucharptr)cvbnodetmp + psvbptr->inodesize - 2;
    memset (cvbnodetmp, 0, VB_NODE_MAX);
#if ISAMMODE == 1
    inl_stquad (inl_ldquad (psvbptr->sdictnode.ctransnumber) + 1,
            cvbnodetmp + INTSIZE);
    pcnodeptr = (ucharptr)cvbnodetmp + INTSIZE + QUADSIZE;
#else
    pcnodeptr = (ucharptr)cvbnodetmp + INTSIZE;
#endif
    *pcnodeend = pstree->ilevel;
    pstree->ikeysinnode = 0;
    for (pskey = pstree->pskeyfirst; pskey && !pskey->iisdummy;
         pskey = pskey->psnext) {
        pstree->pskeylist[pstree->ikeysinnode] = pskey;
        pstree->ikeysinnode++;
        if (!pskeyhalfway) {
            if (pcnodeptr >= pcnodehalfway) {
                pskeyhalfway = pskey->psprev;
            }
        }
        ikeylen = pskeydesc->k_len;
        if (pskeydesc->k_flags & TCOMPRESS) {
            ilasttc = icounttc;
            icounttc = 0;
            pckeyendptr = pskey->ckey + ikeylen - 1;
            while (*pckeyendptr-- == TCC && pckeyendptr != pskey->ckey) {
                icounttc++;
            }
#if ISAMMODE == 1
            ikeylen += INTSIZE - icounttc;
#else
            ikeylen += 1 - icounttc;
#endif
        }
        if (pskeydesc->k_flags & LCOMPRESS) {
            icountlc = 0;
            if (pskey != pstree->pskeyfirst) {
                imaxtc = pskeydesc->k_len - (icounttc >
                                 ilasttc ? icounttc : ilasttc);
                for (; pskey->ckey[icountlc] == pcprevkey[icountlc]
                     && icountlc < imaxtc; icountlc++) ;
            }
#if ISAMMODE == 1
            ikeylen += INTSIZE - icountlc;
#else
            ikeylen += 1 - icountlc;
#endif
            if (pskey->iishigh && pskeydesc->k_flags && LCOMPRESS) {
                icountlc = pskeydesc->k_len;
                icounttc = 0;
#if ISAMMODE == 1
                if (pskeydesc->k_flags && TCOMPRESS) {
                    ikeylen = INTSIZE * 2;
                } else {
                    ikeylen = INTSIZE;
                }
#else
                if (pskeydesc->k_flags && TCOMPRESS) {
                    ikeylen = 2;
                } else {
                    ikeylen = 1;
                }
#endif
                if (pskeydesc->k_flags & DCOMPRESS) {
                    ikeylen = 0;
                }
            }
        }
        if (pskeydesc->k_flags & ISDUPS) {
            ikeylen += QUADSIZE;
            /* If the key is a duplicate and it's not first in node */
            if (pskey->iishigh || (pskey != pstree->pskeyfirst
                && !memcmp (pskey->ckey, pcprevkey, (size_t)pskeydesc->k_len))) {
                if (pskeydesc->k_flags & DCOMPRESS) {
                    ikeylen = QUADSIZE;
                }
            }
        }
        ikeylen += QUADSIZE;
        /* Split? */
        if (pcnodeptr + ikeylen >= pcnodeend - 1) {
            if (pstree->pskeylast->psprev->iisnew) {
                pskeyhalfway = pstree->pskeylast->psprev->psprev;
            }
            if (pstree->pskeylast->psprev->iishigh
                && pstree->pskeylast->psprev->psprev->iisnew) {
                pskeyhalfway = pstree->pskeylast->psprev->psprev->psprev;
            }
            iresult = inodesplit (ihandle, ikeynumber, pstree, pskeyhalfway);
            return iresult;
        }
        if (((ikeylen == (QUADSIZE * 2))
             && ((pskeydesc->k_flags & (DCOMPRESS | ISDUPS)) == (DCOMPRESS | ISDUPS)))
            || (pskeydesc->k_flags & DCOMPRESS && !(pskeydesc->k_flags & ISDUPS)
            && ikeylen == QUADSIZE)) {
            *(pcnodeptr - QUADSIZE) |= 0x80;
        } else {
            if (pskeydesc->k_flags & LCOMPRESS) {
#if ISAMMODE == 1
                inl_stint (icountlc, pcnodeptr);
                pcnodeptr += INTSIZE;
#else
                *pcnodeptr++ = icountlc;
#endif
            }
            if (pskeydesc->k_flags & TCOMPRESS) {
#if ISAMMODE == 1
                inl_stint (icounttc, pcnodeptr);
                pcnodeptr += INTSIZE;
#else
                *pcnodeptr++ = icounttc;
#endif
            }
            if (icountlc != pskeydesc->k_len) {
                pcprevkey = pskey->ckey + icountlc;
                imaxtc = pskeydesc->k_len - (icountlc + icounttc);
                while (imaxtc--) {
                    *pcnodeptr++ = *pcprevkey++;
                }
            }
            pcprevkey = pskey->ckey;
        }
        if (pskeydesc->k_flags & ISDUPS) {
            inl_stquad (pskey->tdupnumber, pcnodeptr);
            pcnodeptr += QUADSIZE;
        }
        inl_stquad (pskey->trownode, pcnodeptr);
        pcnodeptr += QUADSIZE;
    }
    if (pskey && pskey->iisdummy) {
        pstree->pskeylist[pstree->ikeysinnode] = pskey;
        pstree->ikeysinnode++;
    }
    inl_stint ((int)((ucharptr)pcnodeptr - (ucharptr)cvbnodetmp), cvbnodetmp);
    return ivbblockwrite (ihandle, 1, tnodenumber, cvbnodetmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbopen	(	const char *	pcfilename,
		const int	iflags,
		const mode_t	tmode
	)

Definition at line 32 of file vblowlevel.c.

References VBFILE::ihandle, iinitialized, VBFILE::irefcount, O_BINARY, svbfile, VBFILE::tdevice, VBFILE::tinode, and VB_MAX_FILES.

Referenced by isbuild(), islogopen(), and isopen().

{
    int     iloop;
    struct stat sstat;

    if (!iinitialized) {
        memset ((void *)&svbfile[0], 0, sizeof (svbfile));
        iinitialized = 1;
    }
    if (stat (pcfilename, &sstat)) {
        if (!iflags & O_CREAT) {
            return -1;
        }
    } else {
        for (iloop = 0; iloop < VB_MAX_FILES * 3; iloop++) {
            if (svbfile[iloop].irefcount
                && svbfile[iloop].tdevice == sstat.st_dev
#ifdef  _WIN32
                && !strcmp(svbfile[iloop].cfilename, pcfilename)) {
#else
                && svbfile[iloop].tinode == sstat.st_ino) {
#endif
                svbfile[iloop].irefcount++;
                return iloop;
            }
        }
    }
    for (iloop = 0; iloop < VB_MAX_FILES * 3; iloop++) {
        if (svbfile[iloop].irefcount == 0) {
            svbfile[iloop].ihandle = open (pcfilename, iflags | O_BINARY, tmode);
            if (svbfile[iloop].ihandle == -1) {
                break;
            }
            if ((iflags & O_CREAT) && stat (pcfilename, &sstat)) {
                close (svbfile[iloop].ihandle);
                return -1;
            }
#ifdef  _WIN32
            svbfile[iloop].tinode = 0;
            if (svbfile[iloop].cfilename) {
                free (svbfile[iloop].cfilename);
            }
            svbfile[iloop].whandle = (HANDLE)_get_osfhandle (svbfile[iloop].ihandle);
            if (svbfile[iloop].whandle == INVALID_HANDLE_VALUE) {
                close (svbfile[iloop].ihandle);
                return -1;
            }
            svbfile[iloop].cfilename = strdup (pcfilename);
#else
            svbfile[iloop].tinode = sstat.st_ino;
#endif
            svbfile[iloop].tdevice = sstat.st_dev;
            svbfile[iloop].irefcount++;
            return iloop;
        }
    }
    errno = ENOENT;
    return -1;
}

Here is the caller graph for this function:

int ivbtransbuild	(	const char *	pcfilename,
		const int	iminrowlen,
		const int	imaxrowlen,
		struct keydesc *	pskeydesc,
		const int	imode
	)

Definition at line 599 of file istrans.c.

References cvbtransbuffer, inl_stint(), iserrno, ivbintrans, ivblogfilehandle, iwritebegin(), iwritetrans(), VBBEGIN, VBL_BUILD, VBNEEDFLUSH, and vtranshdr().

Referenced by isbuild().

{
    char        *pcbuffer;
    struct keypart  *pskptr;
    int     ilength = 0, ilength2, iloop;

    if (ivblogfilehandle < 0 || imode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_BUILD);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (imode, pcbuffer);
    inl_stint (iminrowlen, pcbuffer + INTSIZE);
    inl_stint (imaxrowlen, pcbuffer + (2 * INTSIZE));
    inl_stint (pskeydesc->k_flags, pcbuffer + (3 * INTSIZE));
    inl_stint (pskeydesc->k_nparts, pcbuffer + (4 * INTSIZE));
    pcbuffer += (INTSIZE * 6);
    for (iloop = 0; iloop < pskeydesc->k_nparts; iloop++) {
        pskptr = &pskeydesc->k_part[iloop];
        inl_stint (pskptr->kp_start, pcbuffer + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_leng,
               pcbuffer + INTSIZE + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_type,
               pcbuffer + (INTSIZE * 2) + (iloop * 3 * INTSIZE));
        ilength += pskptr->kp_leng;
    }
    inl_stint (ilength, pcbuffer - INTSIZE);
    ilength = (INTSIZE * 6) + (INTSIZE * 3 * (pskeydesc->k_nparts));
    ilength2 = strlen (pcfilename) + 1;
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR) + ilength;
    memcpy (pcbuffer, pcfilename, (size_t)ilength2);
    iserrno = iwritetrans (ilength + ilength2, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransclose	(	const int	ihandle,
		const char *	pcfilename
	)

Definition at line 806 of file istrans.c.

References cvbtransbuffer, inl_stint(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, iwritebegin(), iwritetrans(), psvbfile, VBBEGIN, VBL_FILECLOSE, VBROLLBACK, and vtranshdr().

Referenced by ivbclose2().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;
    int     ilength;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || psvbptr->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBROLLBACK) {
        return 0;
    }
    if (psvbptr->itransyet == 0) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_FILECLOSE);
    ilength = strlen (pcfilename) + 1;
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stint (psvbptr->iopenmode & ISVARLEN, pcbuffer + INTSIZE);  /* VARLEN flag! */
    memcpy (pcbuffer + INTSIZE + INTSIZE, pcfilename, (size_t)ilength);
    ilength += (INTSIZE * 2);
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtranscluster

(

void

)

Definition at line 691 of file istrans.c.

{
    /* BUG - Write ivbtranscluster */
    return 0;
}

int ivbtranscreateindex	(	const int	ihandle,
		struct keydesc *	pskeydesc
	)

Definition at line 648 of file istrans.c.

References cvbtransbuffer, inl_stint(), iserrno, ivbintrans, ivblogfilehandle, iwritebegin(), iwritetrans(), psvbfile, VBBEGIN, VBL_CREINDEX, VBNEEDFLUSH, and vtranshdr().

Referenced by isaddindex().

{
    char        *pcbuffer;
    struct keypart  *pskptr;
    int     ilength = 0, iloop;

    if (ivblogfilehandle < 0 || psvbfile[ihandle]->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_CREINDEX);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stint (pskeydesc->k_flags, pcbuffer + INTSIZE);
    inl_stint (pskeydesc->k_nparts, pcbuffer + (2 * INTSIZE));
    pcbuffer += (INTSIZE * 4);
    for (iloop = 0; iloop < pskeydesc->k_nparts; iloop++) {
        pskptr = &pskeydesc->k_part[iloop];
        inl_stint (pskptr->kp_start, pcbuffer + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_leng,
               pcbuffer + INTSIZE + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_type,
               pcbuffer + (INTSIZE * 2) + (iloop * 3 * INTSIZE));
        ilength += pskptr->kp_leng;
    }
    inl_stint (ilength, pcbuffer - INTSIZE);
    ilength = (INTSIZE * 4) + (INTSIZE * 3 * (pskeydesc->k_nparts));
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransdelete	(	const int	ihandle,
		off_t	trownumber,
		int	irowlength
	)

Definition at line 698 of file istrans.c.

References DICTINFO::cfilename, cvbtransbuffer, inl_stint(), inl_stquad(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, ivbtransopen(), iwritebegin(), iwritetrans(), DICTINFO::ppcrowbuffer, psvbfile, QUADSIZE, VBBEGIN, VBL_DELETE, VBNEEDFLUSH, and vtranshdr().

Referenced by iprocessdelete().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || psvbptr->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    if (psvbptr->itransyet == 0) {
        ivbtransopen (ihandle, psvbptr->cfilename);
    }
    vtranshdr (VBL_DELETE);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stquad (trownumber, pcbuffer + INTSIZE);
    inl_stint (irowlength, pcbuffer + INTSIZE + QUADSIZE);
    memcpy (pcbuffer + INTSIZE + QUADSIZE + INTSIZE, psvbptr->ppcrowbuffer, (size_t)irowlength);
    irowlength += (INTSIZE * 2) + QUADSIZE;
    iserrno = iwritetrans (irowlength, 1);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransdeleteindex	(	const int	ihandle,
		struct keydesc *	pskeydesc
	)

Definition at line 734 of file istrans.c.

References cvbtransbuffer, inl_stint(), iserrno, ivbintrans, ivblogfilehandle, iwritebegin(), iwritetrans(), psvbfile, VBBEGIN, VBL_DELINDEX, VBNEEDFLUSH, and vtranshdr().

Referenced by isdelindex().

{
    char        *pcbuffer;
    struct keypart  *pskptr;
    int     ilength = 0, iloop;

    if (ivblogfilehandle < 0 || psvbfile[ihandle]->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_DELINDEX);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stint (pskeydesc->k_flags, pcbuffer + INTSIZE);
    inl_stint (pskeydesc->k_nparts, pcbuffer + (2 * INTSIZE));
    pcbuffer += (INTSIZE * 4);
    for (iloop = 0; iloop < pskeydesc->k_nparts; iloop++) {
        pskptr = &pskeydesc->k_part[iloop];
        inl_stint (pskptr->kp_start, pcbuffer + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_leng,
               pcbuffer + INTSIZE + (iloop * 3 * INTSIZE));
        inl_stint (pskptr->kp_type,
               pcbuffer + (INTSIZE * 2) + (iloop * 3 * INTSIZE));
        ilength += pskptr->kp_leng;
    }
    inl_stint (ilength, pcbuffer - INTSIZE);
    ilength = (INTSIZE * 4) + (INTSIZE * 3 * (pskeydesc->k_nparts));
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtranserase

(

const char *

pcfilename

)

Definition at line 777 of file istrans.c.

References cvbtransbuffer, iserrno, ivbintrans, ivblogfilehandle, iwritebegin(), iwritetrans(), VBBEGIN, VBL_FILEERASE, VBNEEDFLUSH, and vtranshdr().

Referenced by iserase().

{
    char    *pcbuffer;
    int ilength;

    if (ivblogfilehandle < 0) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_FILEERASE);
    ilength = strlen (pcfilename) + 1;
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    memcpy (pcbuffer, pcfilename, (size_t)ilength);
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransinsert	(	const int	ihandle,
		const off_t	trownumber,
		int	irowlength,
		char *	pcrow
	)

Definition at line 878 of file istrans.c.

References DICTINFO::cfilename, cvbtransbuffer, inl_stint(), inl_stquad(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, ivbtransopen(), iwritebegin(), iwritetrans(), psvbfile, QUADSIZE, VBBEGIN, VBL_INSERT, VBNEEDFLUSH, and vtranshdr().

Referenced by ivbwriterow().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || psvbptr->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    if (psvbptr->itransyet == 0) {
        ivbtransopen (ihandle, psvbptr->cfilename);
    }
    vtranshdr (VBL_INSERT);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stquad (trownumber, pcbuffer + INTSIZE);
    inl_stint (irowlength, pcbuffer + INTSIZE + QUADSIZE);
    memcpy (pcbuffer + INTSIZE + QUADSIZE + INTSIZE, pcrow, (size_t)irowlength);
    irowlength += (INTSIZE * 2) + QUADSIZE;
    iserrno = iwritetrans (irowlength, 1);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransopen	(	const int	ihandle,
		const char *	pcfilename
	)

Definition at line 843 of file istrans.c.

References cvbtransbuffer, inl_stint(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, iwritebegin(), iwritetrans(), psvbfile, VBBEGIN, VBL_FILEOPEN, VBNEEDFLUSH, and vtranshdr().

Referenced by isopen(), ivbtransdelete(), ivbtransinsert(), ivbtranssetunique(), ivbtransuniqueid(), and ivbtransupdate().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;
    int     ilength;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || psvbptr->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    psvbptr->itransyet = 2;
    vtranshdr (VBL_FILEOPEN);
    ilength = strlen (pcfilename) + 1;
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stint (psvbptr->iopenmode & ISVARLEN, pcbuffer + INTSIZE);  /* VARLEN flag! */
    memcpy (pcbuffer + INTSIZE + INTSIZE, pcfilename, (size_t)ilength);
    ilength += (INTSIZE * 2);
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransrename	(	char *	pcoldname,
		char *	pcnewname
	)

Definition at line 914 of file istrans.c.

References cvbtransbuffer, inl_stint(), iserrno, ivbintrans, ivblogfilehandle, iwritebegin(), iwritetrans(), VBBEGIN, VBL_RENAME, VBNEEDFLUSH, and vtranshdr().

Referenced by isrename().

{
    char    *pcbuffer;
    int ilength, ilength1, ilength2;

    if (ivblogfilehandle < 0) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    vtranshdr (VBL_RENAME);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    ilength1 = strlen (pcoldname) + 1;
    ilength2 = strlen (pcnewname) + 1;
    inl_stint (ilength1, pcbuffer);
    inl_stint (ilength2, pcbuffer + INTSIZE);
    memcpy (pcbuffer + (INTSIZE * 2), pcoldname, (size_t)ilength1);
    memcpy (pcbuffer + (INTSIZE * 2) + ilength1, pcnewname, (size_t)ilength2);
    ilength = (INTSIZE * 2) + ilength1 + ilength2;
    iserrno = iwritetrans (ilength, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtranssetunique	(	const int	ihandle,
		const off_t	tuniqueid
	)

Definition at line 948 of file istrans.c.

References DICTINFO::cfilename, cvbtransbuffer, inl_stint(), inl_stquad(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, ivbtransopen(), iwritebegin(), iwritetrans(), psvbfile, QUADSIZE, VBBEGIN, VBL_SETUNIQUE, VBNEEDFLUSH, and vtranshdr().

Referenced by issetunique().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || psvbptr->iopenmode & ISNOLOG) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    if (psvbptr->itransyet == 0) {
        ivbtransopen (ihandle, psvbptr->cfilename);
    }
    vtranshdr (VBL_SETUNIQUE);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stquad (tuniqueid, pcbuffer + INTSIZE);
    iserrno = iwritetrans (INTSIZE + QUADSIZE, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransuniqueid	(	const int	ihandle,
		const off_t	tuniqueid
	)

Definition at line 981 of file istrans.c.

References DICTINFO::cfilename, cvbtransbuffer, inl_stint(), inl_stquad(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, ivblogfilehandle, ivbtransopen(), iwritebegin(), iwritetrans(), psvbfile, QUADSIZE, VBBEGIN, VBL_UNIQUEID, VBNEEDFLUSH, and vtranshdr().

Referenced by isuniqueid().

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || (psvbptr->iopenmode & ISNOLOG)) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    if (psvbptr->itransyet == 0) {
        ivbtransopen (ihandle, psvbptr->cfilename);
    }
    vtranshdr (VBL_UNIQUEID);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stquad (tuniqueid, pcbuffer + INTSIZE);
    iserrno = iwritetrans (INTSIZE + QUADSIZE, 0);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbtransupdate	(	const int	ihandle,
		const off_t	trownumber,
		const int	ioldrowlen,
		const int	inewrowlen,
		const char *	pcrow
	)

Definition at line 1014 of file istrans.c.

References DICTINFO::cfilename, cvbtransbuffer, inl_stint(), inl_stquad(), DICTINFO::iopenmode, iserrno, DICTINFO::itransyet, ivbintrans, ivblogfilehandle, ivbtransopen(), iwritebegin(), iwritetrans(), DICTINFO::ppcrowbuffer, psvbfile, QUADSIZE, VBBEGIN, VBL_UPDATE, VBNEEDFLUSH, and vtranshdr().

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

{
    struct DICTINFO *psvbptr;
    char        *pcbuffer;
    int     ilength;

    psvbptr = psvbfile[ihandle];
    if (ivblogfilehandle < 0 || (psvbptr->iopenmode & ISNOLOG)) {
        return 0;
    }
    /* Don't log transactions if we're in rollback / recover mode */
    if (ivbintrans > VBNEEDFLUSH) {
        return 0;
    }
    if (ivbintrans == VBBEGIN) {
        if (iwritebegin ()) {
            return -1;
        }
    }
    if (psvbptr->itransyet == 0) {
        ivbtransopen (ihandle, psvbptr->cfilename);
    }
    vtranshdr (VBL_UPDATE);
    pcbuffer = cvbtransbuffer + sizeof (struct SLOGHDR);
    inl_stint (ihandle, pcbuffer);
    inl_stquad (trownumber, pcbuffer + INTSIZE);
    inl_stint (ioldrowlen, pcbuffer + INTSIZE + QUADSIZE);
    inl_stint (inewrowlen, pcbuffer + INTSIZE + QUADSIZE + INTSIZE);
    memcpy (pcbuffer + INTSIZE + QUADSIZE + INTSIZE + INTSIZE, psvbptr->ppcrowbuffer,
        (size_t)ioldrowlen);
    memcpy (pcbuffer + INTSIZE + QUADSIZE + INTSIZE + INTSIZE + ioldrowlen, pcrow,
        (size_t)inewrowlen);
    ilength = INTSIZE + QUADSIZE + (INTSIZE * 2) + ioldrowlen + inewrowlen;
    iserrno = iwritetrans (ilength, 1);
    if (iserrno) {
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ivbwriterow	(	const int	ihandle,
		char *	pcrow,
		const off_t	trownumber
	)

Definition at line 85 of file iswrite.c.

References DICTINFO::iminrowlength, DICTINFO::iopenmode, irowinsert(), iserrno, isreclen, isrecnum, ivbdatalock(), ivbdatawrite(), ivbtransinsert(), psvbfile, DICTINFO::trownumber, DICTINFO::tvarlennode, VBUNLOCK, and VBWRLOCK.

Referenced by ircvinsert(), iswrcurr(), iswrite(), and ivbrollmeback().

{
    struct DICTINFO *psvbptr;
    int     iresult = 0;

    psvbptr = psvbfile[ihandle];
    isrecnum = trownumber;
    if (psvbptr->iopenmode & ISTRANS) {
        iserrno = ivbdatalock (ihandle, VBWRLOCK, trownumber);
        if (iserrno) {
            return -1;
        }
    }
    iresult = irowinsert (ihandle, pcrow, trownumber);
    if (!iresult) {
        iserrno = 0;
        psvbptr->tvarlennode = 0;   /* Stop it from removing */
        iresult = ivbdatawrite (ihandle, (void *)pcrow, 0, trownumber);
        if (iresult) {
            iserrno = iresult;
            if (psvbptr->iopenmode & ISTRANS) {
                ivbdatalock (ihandle, VBUNLOCK, trownumber);
            }
            return -1;
        }
        if (psvbptr->iopenmode & ISVARLEN) {
            iresult = ivbtransinsert (ihandle, trownumber,
                    isreclen, pcrow);
        } else {
            iresult = ivbtransinsert (ihandle, trownumber,
                    psvbptr->iminrowlength, pcrow);
        }
    }
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct VBKEY* psvbkeyallocate	(	const int	ihandle,
		const int	ikeynumber
	)

Definition at line 120 of file vbmemio.c.

References NULL, DICTINFO::pskeydesc, DICTINFO::pskeyfree, VBKEY::psnext, psvbfile, pvvbmalloc(), VBKEY::trownode, and vb_error.

Referenced by inodesplit(), ivbkeyinsert(), and ivbnodeload().

{
    struct VBKEY    *pskey;
    struct DICTINFO *psvbptr;
    int     ilength = 0;

    psvbptr = psvbfile[ihandle];
    pskey = psvbptr->pskeyfree[ikeynumber];
    if (pskey == NULL) {
        ilength = psvbptr->pskeydesc[ikeynumber]->k_len;
        pskey = pvvbmalloc (sizeof (struct VBKEY) + ilength);
    } else {
        if (pskey->trownode != -1) {
            vb_error ("Keyallocated not free");
        }
        psvbptr->pskeyfree[ikeynumber] =
            psvbptr->pskeyfree[ikeynumber]->psnext;
        memset (pskey, 0, (sizeof (struct VBKEY) + ilength));
    }
    return pskey;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct VBLOCK* psvblockallocate

(

const int

ihandle

)

Definition at line 67 of file vbmemio.c.

References NULL, pslockfree, VBLOCK::psnext, and pvvbmalloc().

Referenced by ilockinsert().

{
    struct VBLOCK *pslock = pslockfree;

    if (pslockfree != NULL) {
        pslockfree = pslockfree->psnext;
        memset (pslock, 0, sizeof (struct VBLOCK));
    } else {
        pslock = pvvbmalloc (sizeof (struct VBLOCK));
    }
    return pslock;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct VBTREE* psvbtreeallocate

(

const int

ihandle

)

Definition at line 88 of file vbmemio.c.

References NULL, VBTREE::psnext, pstreefree, pvvbmalloc(), VBTREE::tnodenumber, and vb_error.

Referenced by inodesplit(), itreeload(), and ivbkeyload().

{
    struct VBTREE *pstree = pstreefree;

    if (pstreefree == NULL) {
        pstree = pvvbmalloc (sizeof (struct VBTREE));
    } else {
        pstreefree = pstreefree->psnext;
        if (pstree->tnodenumber != -1) {
            vb_error ("Treeallocated not free");
        }
        memset (pstree, 0, sizeof (struct VBTREE));
    }
    return pstree;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* pvvbmalloc

(

const size_t

size

)

Definition at line 45 of file vbmemio.c.

References unlikely.

Referenced by ipreamble(), iprocessdelete(), ircvbegin(), ircvchecktrans(), ircvfileopen(), isaddindex(), isbuild(), isdi_kdsc(), isopen(), isrecover(), psvbkeyallocate(), psvblockallocate(), and psvbtreeallocate().

{
    void    *mptr;

    mptr = calloc (1, size);
    if (unlikely(!mptr)) {
        fprintf (stderr, "Cannot allocate %d bytes of memory - Aborting\n", size);
        fflush (stderr);
        exit (1);
    }
    return mptr;
}

Here is the caller graph for this function:

off_t tvbdataallocate

(

const int

ihandle

)

Definition at line 284 of file vbindexio.c.

References DICTNODE::cdatafree, cvbnodetmp, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, iserrno, ivbblockread(), ivbblockwrite(), ivbnodefree(), psvbfile, QUADSIZE, DICTINFO::sdictnode, and tvbdatacountgetnext().

Referenced by iswrcurr(), and iswrite().

{
    struct DICTINFO *psvbptr;
    off_t       theadnode, tnextnode, tvalue;
    int     ilengthused, iresult;

    psvbptr = psvbfile[ihandle];
    iserrno = EBADARG;
    if (!psvbptr->iisdictlocked) {
        return -1;
    }
    iserrno = 0;

    /* If there's *ANY* rows in the free list, use them first! */
    theadnode = inl_ldquad (psvbptr->sdictnode.cdatafree);
    while (theadnode != 0) {
        iserrno = ivbblockread (ihandle, 1, theadnode, cvbnodetmp);
        if (iserrno) {
            return -1;
        }
        iserrno = EBADFILE;
/* C-ISAM is not 100% C-ISAM compatible */
#if ISAMMODE == 1
        if (cvbnodetmp[psvbptr->inodesize - 2] != 0x7f) {
            return -1;
        }
#endif
        if (cvbnodetmp[psvbptr->inodesize - 3] != -1) {
            return -1;
        }
        ilengthused = inl_ldint (cvbnodetmp);
        if (ilengthused > INTSIZE + QUADSIZE) {
            psvbptr->iisdictlocked |= 0x02;
            ilengthused -= QUADSIZE;
            inl_stint (ilengthused, cvbnodetmp);
            tvalue = inl_ldquad (&cvbnodetmp[ilengthused]);
            inl_stquad ((off_t)0, &cvbnodetmp[ilengthused]);
            if (ilengthused > INTSIZE + QUADSIZE) {
                iserrno = ivbblockwrite (ihandle, 1, theadnode, cvbnodetmp);
                if (iserrno) {
                    return -1;
                }
                return tvalue;
            }
            /* If we're using the last entry in the node, advance */
            tnextnode = inl_ldquad (&cvbnodetmp[INTSIZE]);
            iresult = ivbnodefree (ihandle, theadnode);
            if (iresult) {
                return -1;
            }
            inl_stquad (tnextnode, psvbptr->sdictnode.cdatafree);
            return tvalue;
        }
        /* Ummmm, this is an INTEGRITY ERROR of sorts! */
        /* However, let's fix it anyway! */
        tnextnode = inl_ldquad (&cvbnodetmp[INTSIZE]);
        iresult = ivbnodefree (ihandle, theadnode);
        if (iresult) {
            return -1;
        }
        inl_stquad (tnextnode, psvbptr->sdictnode.cdatafree);
        psvbptr->iisdictlocked |= 0x02;
        theadnode = tnextnode;
    }
    /* If we get here, we need to allocate a NEW row number. */
    /* Since we already hold a dictionary lock, we don't need another */
    tvalue = tvbdatacountgetnext (ihandle);
    return tvalue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

off_t tvblseek	(	const int	ihandle,
		off_t	toffset,
		const int	iwhence
	)

Definition at line 107 of file vblowlevel.c.

References svbfile, and unlikely.

Referenced by ircvchecktrans(), iscommit(), isrecover(), isrollback(), ivbblockread(), ivbblockwrite(), ivbdataread(), ivbdatawrite(), ivbrollmeback(), ivbrollmeforward(), and iwritetrans().

{
    if (unlikely(!svbfile[ihandle].irefcount)) {
        errno = ENOENT;
        return -1;
    }
    return lseek (svbfile[ihandle].ihandle, toffset, iwhence);
}

Here is the caller graph for this function:

off_t tvbnodeallocate

(

const int

ihandle

)

Definition at line 221 of file vbindexio.c.

References DICTNODE::cnodefree, cvbnodetmp, DICTINFO::iisdictlocked, inl_ldint(), inl_ldquad(), inl_stint(), inl_stquad(), DICTINFO::inodesize, iserrno, ivbblockread(), ivbblockwrite(), psvbfile, QUADSIZE, DICTINFO::sdictnode, and tvbnodecountgetnext().

Referenced by inodesplit(), and ivbdatafree().

{
    struct DICTINFO *psvbptr;
    off_t       theadnode, tvalue;
    int     ilengthused;

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

    /* If there's *ANY* nodes in the free list, use them first! */
    theadnode = inl_ldquad (psvbptr->sdictnode.cnodefree);
    if (theadnode != 0) {
        iserrno = ivbblockread (ihandle, 1, theadnode, cvbnodetmp);
        if (iserrno) {
            return -1;
        }
        iserrno = EBADFILE;
/* C-ISAM is not 100% C-ISAM compatible */
#if ISAMMODE == 1
        if (cvbnodetmp[psvbptr->inodesize - 2] != 0x7f) {
            return -1;
        }
#endif
        if (cvbnodetmp[psvbptr->inodesize - 3] != -2) {
            return -1;
        }
        ilengthused = inl_ldint (cvbnodetmp);
        if (ilengthused > (INTSIZE + QUADSIZE)) {
            tvalue = inl_ldquad (cvbnodetmp + INTSIZE + QUADSIZE);
            memcpy (cvbnodetmp + INTSIZE + QUADSIZE,
                cvbnodetmp + INTSIZE + QUADSIZE + QUADSIZE,
                (size_t)(ilengthused - (INTSIZE + QUADSIZE + QUADSIZE)));
            ilengthused -= QUADSIZE;
            memset (cvbnodetmp + ilengthused, 0, QUADSIZE);
            inl_stint (ilengthused, cvbnodetmp);
            iserrno = ivbblockwrite (ihandle, 1, theadnode, cvbnodetmp);
            if (iserrno) {
                return -1;
            }
            return tvalue;
        }
        /* If it's last entry in the node, use the node itself! */
        tvalue = inl_ldquad (cvbnodetmp + INTSIZE);
        inl_stquad (tvalue, psvbptr->sdictnode.cnodefree);
        psvbptr->iisdictlocked |= 0x02;
        return theadnode;
    }
    /* If we get here, we need to allocate a NEW node. */
    /* Since we already hold a dictionary lock, we don't need another */
    tvalue = tvbnodecountgetnext (ihandle);
    return tvalue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

off_t tvbnodecountgetnext

(

const int

ihandle

)

Definition at line 48 of file vbindexio.c.

References DICTNODE::cnodecount, DICTINFO::iisdictlocked, inl_ldquad(), inl_stquad(), iserrno, psvbfile, and DICTINFO::sdictnode.

Referenced by iaddkeydescriptor(), ivbvarlenwrite(), ttailnode(), and tvbnodeallocate().

{
    struct DICTINFO *psvbptr;
    off_t       tvalue;

    psvbptr = psvbfile[ihandle];
    iserrno = EBADARG;
    if (!psvbptr->iisdictlocked) {
        return -1;
    }
    iserrno = 0;

    tvalue = inl_ldquad (psvbptr->sdictnode.cnodecount) + 1;
    inl_stquad (tvalue, psvbptr->sdictnode.cnodecount);
    psvbptr->iisdictlocked |= 0x02;
    return tvalue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ssize_t tvbread	(	const int	ihandle,
		void *	pvbuffer,
		const size_t	tcount
	)

Definition at line 117 of file vblowlevel.c.

References svbfile, and unlikely.

Referenced by ircvchecktrans(), isrecover(), ivbblockread(), ivbdataread(), ivbrollmeback(), and ivbrollmeforward().

{
    if (unlikely(!svbfile[ihandle].irefcount)) {
        errno = ENOENT;
        return -1;
    }
    return read (svbfile[ihandle].ihandle, pvbuffer, tcount);
}

Here is the caller graph for this function:

ssize_t tvbwrite	(	const int	ihandle,
		const void *	pvbuffer,
		const size_t	tcount
	)

Definition at line 127 of file vblowlevel.c.

References svbfile, and unlikely.

Referenced by ivbblockwrite(), ivbdatawrite(), and iwritetrans().

{
    if (unlikely(!svbfile[ihandle].irefcount)) {
        errno = ENOENT;
        return -1;
    }
    return write (svbfile[ihandle].ihandle, pvbuffer, tcount);
}

Here is the caller graph for this function:

void vvbfree

(

void *

mptr

)

Definition at line 59 of file vbmemio.c.

Referenced by ipostamble(), ircvcommit(), ircvfileopen(), ircvrollback(), isbuild(), isdelindex(), isopen(), isrecover(), ivbclose3(), and vvbkeyunmalloc().

{
    if (mptr) {
        free (mptr);
    }
}

Here is the caller graph for this function:

void vvbkeyallfree	(	const int	ihandle,
		const int	ikeynumber,
		struct VBTREE *	pstree
	)

Definition at line 143 of file vbmemio.c.

References VBTREE::ikeysinnode, NULL, VBKEY::pschild, VBTREE::pskeycurr, VBTREE::pskeyfirst, DICTINFO::pskeyfree, VBTREE::pskeylast, VBKEY::psnext, psvbfile, VBKEY::trownode, vb_error, and vvbtreeallfree().

Referenced by ichecktree(), and vvbtreeallfree().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskeycurr;
    struct VBKEY    *pskeynext;

    psvbptr = psvbfile[ihandle];
    pskeycurr = pstree->pskeyfirst;
    while (pskeycurr) {
        if (pskeycurr->trownode == -1) {
            vb_error ("Keyfreed already free");
        }
        pskeynext = pskeycurr->psnext;
        if (pskeycurr->pschild) {
            vvbtreeallfree (ihandle, ikeynumber, pskeycurr->pschild);
        }
        pskeycurr->pschild = NULL;
        pskeycurr->psnext = psvbptr->pskeyfree[ikeynumber];
        psvbptr->pskeyfree[ikeynumber] = pskeycurr;
        pskeycurr->trownode = -1;
        pskeycurr = pskeynext;
    }
    pstree->pskeyfirst = NULL;
    pstree->pskeylast = NULL;
    pstree->pskeycurr = NULL;
    pstree->ikeysinnode = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vvbkeyfree	(	const int	ihandle,
		const int	ikeynumber,
		struct VBKEY *	pskey
	)

Definition at line 172 of file vbmemio.c.

References NULL, VBKEY::pschild, DICTINFO::pskeyfree, VBKEY::psnext, VBKEY::psprev, psvbfile, VBKEY::trownode, vb_error, and vvbtreeallfree().

Referenced by ivbkeydelete(), and ivbnodeload().

{
    struct DICTINFO *psvbptr;

    if (pskey->trownode == -1) {
        vb_error ("Keyfreed already free");
    }
    psvbptr = psvbfile[ihandle];
    if (pskey->pschild) {
        vvbtreeallfree (ihandle, ikeynumber, pskey->pschild);
    }
    pskey->pschild = NULL;
    if (pskey->psnext) {
        pskey->psnext->psprev = pskey->psprev;
    }
    if (pskey->psprev) {
        pskey->psprev->psnext = pskey->psnext;
    }
    pskey->psnext = psvbptr->pskeyfree[ikeynumber];
    psvbptr->pskeyfree[ikeynumber] = pskey;
    pskey->trownode = -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vvbkeyunmalloc	(	const int	ihandle,
		const int	ikeynumber
	)

Definition at line 196 of file vbmemio.c.

References DICTINFO::pskeyfree, VBKEY::psnext, psvbfile, and vvbfree().

Referenced by isdelindex(), and ivbclose3().

{
    struct DICTINFO *psvbptr;
    struct VBKEY    *pskeycurr;
/* RXW
    int     ilength;
*/

    psvbptr = psvbfile[ihandle];
    pskeycurr = psvbptr->pskeyfree[ikeynumber];
/* RXW
    ilength = sizeof (struct VBKEY) + psvbptr->pskeydesc[ikeynumber]->k_len;
*/
    while (pskeycurr) {
        psvbptr->pskeyfree[ikeynumber] =
            psvbptr->pskeyfree[ikeynumber]->psnext;
        vvbfree (pskeycurr);
        pskeycurr = psvbptr->pskeyfree[ikeynumber];
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vvbkeyvalueset	(	const int	ihigh,
		struct keydesc *	pskeydesc,
		unsigned char *	pckeyvalue
	)

Definition at line 659 of file vbkeysio.c.

References inl_stint(), inl_stlong(), QUADSIZE, stdbl(), and stfloat().

Referenced by inewroot(), ivbkeysearch(), and ivbnodeload().

{
    struct keypart  *pskptr;
    int     ipart, iremainder;
    char        cbuffer[QUADSIZE];

    for (ipart = 0; ipart < pskeydesc->k_nparts; ipart++) {
        pskptr = &pskeydesc->k_part[ipart];
        switch (pskptr->kp_type & ~ISDESC) {
        case CHARTYPE:
            memset (pckeyvalue, ihigh ? 0xff : 0, (size_t)pskptr->kp_leng);
            pckeyvalue += pskptr->kp_leng;
            break;

        case INTTYPE:
            iremainder = pskptr->kp_leng;
            while (iremainder > 0) {
                inl_stint (ihigh ? SHRT_MAX : SHRT_MIN, pckeyvalue);
                pckeyvalue += INTSIZE;
                iremainder -= INTSIZE;
            }
            break;

        case LONGTYPE:
            iremainder = pskptr->kp_leng;
            while (iremainder > 0) {
                inl_stlong (ihigh ? LONG_MAX : LONG_MIN, pckeyvalue);
                pckeyvalue += LONGSIZE;
                iremainder -= LONGSIZE;
            }
            break;

        case QUADTYPE:
            memset (cbuffer, ihigh ? 0xff : 0, QUADSIZE);
            cbuffer[0] = ihigh ? 0x7f : 0x80;
            iremainder = pskptr->kp_leng;
            while (iremainder > 0) {
                memcpy (pckeyvalue, cbuffer, QUADSIZE);
                pckeyvalue += QUADSIZE;
                iremainder -= QUADSIZE;
            }
            break;

        case FLOATTYPE:
            iremainder = pskptr->kp_leng;
            while (iremainder > 0) {
                stfloat (ihigh ? FLT_MAX : FLT_MIN, pckeyvalue);
                pckeyvalue += FLOATSIZE;
                iremainder -= FLOATSIZE;
            }
            break;

        case DOUBLETYPE:
            iremainder = pskptr->kp_leng;
            while (iremainder > 0) {
                stdbl (ihigh ? DBL_MAX : DBL_MIN, pckeyvalue);
                pckeyvalue += DOUBLESIZE;
                iremainder -= DOUBLESIZE;
            }
            break;

        default:
            break;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vvblockfree

(

struct VBLOCK *

pslock

)

Definition at line 81 of file vbmemio.c.

References pslockfree, and VBLOCK::psnext.

Referenced by ilockdelete(), and ivbclose2().

{
    pslock->psnext = pslockfree;
    pslockfree = pslock;
}

Here is the caller graph for this function:

void vvbmakekey	(	const struct keydesc *	pskeydesc,
		char *	pcrow_buffer,
		unsigned char *	pckeyvalue
	)

Definition at line 212 of file vbkeysio.c.

Referenced by imakekeysfromdata(), irowinsert(), irowupdate(), isdelete(), isread(), isrewrite(), isstart(), ivbkeylocaterow(), and vaddkeyforrow().

{
    const struct keypart    *pskptr;
    char            *pcsource;
    int         ipart;

    /* Wierdly enough, a single keypart *CAN* span multiple instances */
    /* EG: Part number 1 might contain 4 long values */
    for (ipart = 0; ipart < pskeydesc->k_nparts; ipart++) {
        pskptr = &pskeydesc->k_part[ipart];
        pcsource = pcrow_buffer + pskptr->kp_start;
        memcpy (pckeyvalue, pcsource, (size_t)pskptr->kp_leng);
        pckeyvalue += pskptr->kp_leng;
    }
}

Here is the caller graph for this function:

void vvbtreeallfree	(	const int	ihandle,
		const int	ikeynumber,
		struct VBTREE *	pstree
	)

Definition at line 105 of file vbmemio.c.

References VBTREE::psnext, pstreefree, VBTREE::tnodenumber, vb_error, and vvbkeyallfree().

Referenced by iindexcheck(), isdelindex(), itreeload(), ivbclose3(), ivbenter(), ivbexit(), ivbkeydelete(), ivbkeyload(), ivbnodeload(), vvbkeyallfree(), and vvbkeyfree().

{
    if (!pstree) {
        return;
    }
    if (pstree->tnodenumber == -1) {
        vb_error ("Treefreed not free");
    }
    vvbkeyallfree (ihandle, ikeynumber, pstree);
    pstree->psnext = pstreefree;
    pstreefree = pstree;
    pstree->tnodenumber = -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vvbunmalloc

(

void

)

Variable Documentation

int ivbintrans

Definition at line 23 of file istrans.c.

Referenced by iprocessdelete(), isbegin(), isclose(), iscommit(), islogclose(), isopen(), isrecover(), isrelcurr(), isrelease(), isrollback(), ivbenter(), ivbtransbuild(), ivbtransclose(), ivbtranscreateindex(), ivbtransdelete(), ivbtransdeleteindex(), ivbtranserase(), ivbtransinsert(), ivbtransopen(), ivbtransrename(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), and iwritetrans().

int ivblogfilehandle

Definition at line 24 of file istrans.c.

Referenced by ircvchecktrans(), isbegin(), iscleanup(), iscommit(), islogclose(), islogopen(), isopen(), isrecover(), isrollback(), ivbrollmeback(), ivbrollmeforward(), ivbtransbuild(), ivbtranscreateindex(), ivbtransdeleteindex(), ivbtranserase(), ivbtransrename(), ivbtransuniqueid(), ivbtransupdate(), and iwritetrans().

int ivbmaxusedhandle

Definition at line 26 of file vblocking.c.

Referenced by idemotelocks(), isaudit(), isbuild(), iscleanup(), isclose(), iscluster(), iscommit(), isdi_curidx(), isdi_datfd(), isdi_datlen(), isdi_idxfd(), isdi_kdsc(), isdi_name(), iserase(), isflush(), isfullclose(), isindexinfo(), islock(), isopen(), isrelcurr(), isrelease(), isrelrec(), isrollback(), issetcollate(), isunlock(), ivbdatalock(), ivbdataread(), ivbdatawrite(), ivbenter(), and ivbfileopenlock().

struct DICTINFO* psvbfile[128+1]

Definition at line 23 of file vblowlevel.c.

Referenced by iaddkeydescriptor(), icheckkey(), icheckkeydesc(), idatafreecheck(), idelnodes(), idemotelocks(), iindexcheck(), iindexfreecheck(), ilockdelete(), ilockinsert(), imakekeysfromdata(), inewroot(), inodesplit(), ipostamble(), ipreamble(), iprocessdelete(), iquicknodesave(), ircvcreateindex(), ircvdeleteindex(), ircvinsert(), ircvuniqueid(), irowdelete(), irowinsert(), irowupdate(), isaddindex(), isbuild(), ischeck(), iscleanup(), isclose(), iscommit(), isdelcurr(), isdelete(), isdelindex(), isdelrec(), isdi_curidx(), isdi_datfd(), isdi_datlen(), isdi_idxfd(), isdi_kdsc(), isdi_name(), iserase(), isflush(), isindexinfo(), islock(), isopen(), isread(), isrecover(), isrelcurr(), isrelease(), isrelrec(), isrewcurr(), isrewrec(), isrewrite(), isrollback(), issetcollate(), issetunique(), isstart(), istartrownumber(), isuniqueid(), isunlock(), iswrcurr(), iswrite(), itreeload(), ivbcheckkey(), ivbclose2(), ivbclose3(), ivbdatafree(), ivbdatalock(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbexit(), ivbfileopenlock(), ivbforcedataallocate(), ivbforceexit(), ivbkeycompare(), ivbkeydelete(), ivbkeyinsert(), ivbkeyload(), ivbkeylocaterow(), ivbkeysearch(), ivbnodefree(), ivbnodeload(), ivbnodesave(), ivbrollmeback(), ivbrollmeforward(), ivbtransclose(), ivbtranscreateindex(), ivbtransdelete(), ivbtransdeleteindex(), ivbtransinsert(), ivbtransopen(), ivbtranssetunique(), ivbtransuniqueid(), ivbtransupdate(), ivbvarlendelete(), ivbvarlenread(), ivbvarlenwrite(), ivbwriterow(), psvbkeyallocate(), tdelkeydescriptor(), ttailnode(), tvbdataallocate(), tvbdatacountgetnext(), tvbnodeallocate(), tvbnodecountgetnext(), vaddkeyforrow(), vcloseall(), vrebuildindexfree(), vvbkeyallfree(), vvbkeyfree(), and vvbkeyunmalloc().

struct VBFILE svbfile[128 *3]

Definition at line 24 of file vblowlevel.c.

Referenced by ilockdelete(), ilockinsert(), ipreamble(), ivbclose(), ivbclose2(), ivbdatalock(), ivblock(), ivbopen(), tvblseek(), tvbread(), and tvbwrite().