gdk.h

这个是内存数据库中的一个管理工具

#ifndef _GDK_H_
#define _GDK_H_

#include <monet_utils.h>

/* standard includes upon which all configure tests depend */
#include <stdio.h>
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <stddef.h>
#else
# ifdef HAVE_STDLIB_H
#  include <stdlib.h>
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
#  include <memory.h>
# endif
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#else
# ifdef HAVE_STDINT_H
#  include <stdint.h>
# endif
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#include <ctype.h>		/* isspace etc. */

#ifdef HAVE_SYS_FILE_H
# include <sys/file.h>
#endif
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>		/* MAXPATHLEN */
#endif

#ifdef HAVE_DIRENT_H
# include <dirent.h>
# define NAMLEN(dirent) strlen((dirent)->d_name)
#else
# define dirent direct
# define NAMLEN(dirent) (dirent)->d_namlen
# ifdef HAVE_SYS_NDIR_H
#  include <sys/ndir.h>
# endif
# ifdef HAVE_SYS_DIR_H
#  include <sys/dir.h>
# endif
# ifdef HAVE_NDIR_H
#  include <ndir.h>
# endif
#endif

#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif
#ifndef WEXITSTATUS
# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
#endif
#ifndef WIFEXITED
# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
#endif


#ifdef __cplusplus
extern "C" {
#endif

#include "gdk_system.h"
#include "gdk_posix.h"
#include <stream.h>

#undef MIN
#undef MAX
#define MAX(A,B)	((A)<(B)?(B):(A))
#define MIN(A,B)	((A)>(B)?(B):(A))

/* defines from ctype with casts that allow passing char values */
#define GDKisprint(c)   isprint((int) ((unsigned char) (c)))
#define GDKisspace(c)   isspace((int) ((unsigned char) (c)))
#define GDKisalnum(c)   isalnum((int) ((unsigned char) (c)))
#define GDKisgraph(c)   isgraph((int) ((unsigned char) (c)))
#define GDKisdigit(c)   (((unsigned char) (c)) >= '0' && ((unsigned char) (c)) <= '9')
#define GDKisxcntrl(c)  (((unsigned char) (c)) >= 128 && ((unsigned char) (c)) <= 160)
#define GDKisspecial(c) (((unsigned char) (c)) >= 161 && ((unsigned char) (c)) <= 191)
#define GDKisupperl(c)  (((unsigned char) (c)) >= 192 && ((unsigned char) (c)) <= 223)
#define GDKislowerl(c)  (((unsigned char) (c)) >= 224 && ((unsigned char) (c)) <= 255)

#define GDKPROP		6	/*      use one spare! */
#define MONETHOME	"MONETHOME"
#ifndef NATIVE_WIN32
#define BATDIR          "bat"
#define DELDIR          "bat/DELETE_ME"
#define BAKDIR          "bat/BACKUP"
#define SUBDIR          "bat/BACKUP/SUBCOMMIT"
#define LEFTDIR         "bat/LEFTOVERS"
#else
#define BATDIR          "bat"
#define DELDIR          "bat\\DELETE_ME"
#define BAKDIR          "bat\\BACKUP"
#define SUBDIR          "bat\\BACKUP\\SUBCOMMIT"
#define LEFTDIR         "bat\\LEFTOVERS"
#endif
#define DBLOGFILE	"MonetLog"

#ifdef MAXPATHLEN
#define PATHLENGTH 	MAXPATHLEN
#else
#define PATHLENGTH	1024	/* maximum file pathname length */
#endif



#define NEG(A)	(((int)(A))>0?-((int)(A)):((int)(A)))
#define ABS(A)	(((int)(A))>0?((int)(A)):-((int)(A)))

#ifndef TRUE
#define TRUE	1
#define FALSE	0
#endif
#define BOUND2BTRUE	2	/* TRUE, and bound to be so */

#define IDLENGTH	64	/* maximum BAT id length */
#define OLDLENGTH	32	/* old max  BAT id length */
#define BATMARGIN	1.2	/* extra free margin for new heaps */
#define BATTINY_BITS 	8
#define BATTINY		(1<<BATTINY_BITS) /* minimum allocation buncnt for a BAT */

#define TYPE_void	0
#define TYPE_bit	1
#define TYPE_chr	2
#define TYPE_bte	3
#define TYPE_sht	4
#define TYPE_bat	5	/* BAT id: index in BBPcache */
#define TYPE_int	6
#define TYPE_oid	7
#define TYPE_wrd	8
#define TYPE_ptr	9	/* C pointer! */
#define TYPE_flt	10
#define TYPE_dbl	11
#define TYPE_lng	12
#define TYPE_str	13
#define TYPE_any	255	/* limit types to <255! */

typedef signed char bit;
typedef signed char chr;
typedef signed char bte;
typedef short sht;
#ifdef MONET_OID32
#define SIZEOF_OID	SIZEOF_INT
typedef unsigned int oid;
#else
#define SIZEOF_OID	SIZEOF_SIZE_T
typedef size_t oid;
#endif
#define SIZEOF_WRD      SIZEOF_SSIZE_T
typedef ssize_t wrd;
typedef int bat;		/* Index into BBP */
typedef void *ptr;		/* Internal coding of types */
#define SIZEOF_PTR	SIZEOF_VOID_P
typedef float flt;
typedef double dbl;
typedef char *str;

#if SIZEOF_INT==8
#	define LL_CONSTANT(val)     (val)
#elif SIZEOF_LONG==8
#	define LL_CONSTANT(val)     (val##L)
#elif defined(HAVE_LONG_LONG)
#	define LL_CONSTANT(val)     (val##LL)
#elif defined(HAVE___INT64)
#	define LL_CONSTANT(val)     (val##i64)
#endif

/* Base types for all architectures.  These types work on IRIX (64 & 32)
   and for gcc on Linux. */
typedef unsigned char gdk_uint8;
typedef char gdk_int8;

typedef unsigned short gdk_uint16;
typedef short gdk_int16;

typedef unsigned int gdk_uint32;
typedef int gdk_int32;

#ifdef HAVE_LONG_LONG
typedef unsigned long long gdk_uint64;
typedef long long gdk_int64;
#endif

/* define printf formats for printing ptrdiff_t variables */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901 && !defined(__svr4__) && !defined(WIN32) && !defined(__sgi)
#define PDFMT "%td"
#elif SIZEOF_PTRDIFF_T == SIZEOF_INT
#define PDFMT "%d"
#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
#define PDFMT "%ld"
#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG || SIZEOF_PTRDIFF_T == SIZEOF___INT64
#define PDFMT LLFMT
#else
#error no definition for PDFMT
#endif

/* define printf format for printing pointer values */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901
#define PTRFMT		"%p"
#define PTRFMTCAST		/* no cast needed */
#elif SIZEOF_VOID_P == SIZEOF_INT
#define PTRFMT		"%x"
#define PTRFMTCAST	(unsigned int)
#elif SIZEOF_VOID_P == SIZEOF_LONG
#define PTRFMT		"%lx"
#define PTRFMTCAST	(unsigned long)
#elif SIZEOF_VOID_P == SIZEOF_LONG_LONG
#define PTRFMT		"%llx"
#define PTRFMTCAST	(unsigned long long)
#elif SIZEOF_VOID_P == SIZEOF___INT64
#define PTRFMT		"%I64x"
#define PTRFMTCAST	(unsigned __int64)
#else
#error no definition for PTRFMT
#endif

typedef char *BUN;		/* pointer in some heap. */
typedef char long_str[IDLENGTH]; /* standard GDK static string */
typedef char short_str[OLDLENGTH]; /* old GDK small static string */

typedef oid hash_t;		/* type used for hash tables */
#if SIZEOF_OID == SIZEOF_INT
#define HASH_MAX INT_MAX
#else
#define HASH_MAX LLONG_MAX
#endif

typedef oid var_t;		/* type used for heap index of var-sized BAT */
#if SIZEOF_OID == SIZEOF_INT	/* a type compatible with var_t */
#define TYPE_var	TYPE_int
#if SIZEOF_SIZE_T == SIZEOF_INT 
#define OIDFMT		SZFMT
#else
#define OIDFMT		"%u"
#endif
#else
#define TYPE_var	TYPE_lng
#define OIDFMT		SZFMT
#endif



typedef enum { GDK_FAIL, GDK_SUCCEED } gdk_return;

gdk_export int GDKsilent;	/* should GDK shut up? */

#define FATALcheck(tst,	msg) if (tst) GDKfatal(msg);
#define ERRORcheck(tst,	msg) if (tst) { GDKerror(msg); return 0; }
#define WARNcheck(tst,	msg) if (tst) GDKwarning(msg)
#define BATcheck(tst,	msg) if (tst == NULL) {				\
				GDKerror("%s: BAT required.\n",msg);	\
				return 0;				\
			}

/* needed for mel */
#define ATOMextern(t)	(ATOMstorage(t) >= TYPE_str)

#define TYPEcastable(t1,t2)	(ATOMtype(t1)==ATOMtype(t2))
#define TYPEequal(t1,t2)	(ATOMtype(t1)==ATOMtype(t2))
#define TYPEcomp(t1,t2)	(ATOMstorage(ATOMtype(t1))==ATOMstorage(ATOMtype(t2)))
#define TYPEerror(t1,t2)	(!TYPEcomp(t1,t2))
#define TYPEcheck(t1,t2)						\
	if (TYPEerror(t1,t2)) {						\
		GDKerror("TYPEcheck: Incompatible types %s and %s.\n",	\
			ATOMname(t2), ATOMname(t1));			\
		return 0;						\
	} else if (!TYPEcomp(t1,t2)) {					\
		GDKwarning("Interpreting %s as %s.\n",			\
			ATOMname(t2), ATOMname(t1));			\
	}
#define BATcompatible(P1,P2) {						\
	ERRORcheck(P1 == NULL, "BATcompatible: BAT required\n");	\
	ERRORcheck(P2 == NULL, "BATcompatible: BAT required\n");	\
	if (TYPEerror(BAThtype(P1),BAThtype(P2)) ||			\
	    TYPEerror(BATttype(P1),BATttype(P2)))			\
	{								\
		GDKerror("Incompatible operands.\n");			\
		return 0;						\
	}								\
	if (BAThtype(P1) != BAThtype(P2) &&                             \
	    ATOMtype((P1)->htype) != ATOMtype((P2)->htype)) {		\
		GDKwarning("Interpreting %s as %s.\n",			\
			ATOMname(BAThtype(P2)), ATOMname(BAThtype(P1))); \
	}								\
	if (BATttype(P1) != BATttype(P2) &&                             \
	    ATOMtype((P1)->ttype) != ATOMtype((P2)->ttype)) {		\
		GDKwarning("Interpreting %s as %s.\n",			\
			ATOMname(BATttype(P2)), ATOMname(BATttype(P1))); \
	}								\
}


typedef struct {
	size_t maxsize;		/* maximum realloc size (bytes) */
	size_t free;		/* index where free area starts. */
	size_t size;		/* size of the heap (bytes) */
	BUN base;		/* base pointer in memory. */
	char storage;		/* storage mode (mmap/malloc). */
	bit copied;		/* a copy of an existing map. */
	chr newstorage;		/* new desired storage mode at re-allocation. */
	str filename;		/* file containing image of the heap */
} Heap;

typedef struct {
	int type;		/* type of index entity */
	size_t lim;		/* collision list size */
	hash_t mask;		/* number of hash buckets-1 (power of 2) */
	hash_t *hash;		/* hash table */
	hash_t *link;		/* collision list */
	Heap   *heap;		/* heap where the hash is stored */
} Hash;



typedef struct {
	bat id;
	int stamp;
} batrec;

typedef struct {
	union {			/* storage is first in the record */
		int ival;
		oid oval;
		sht shval;
		bte btval;
		wrd wval;
		chr cval[4];
		flt fval;
		ptr pval;
		struct BAT *Bval; /* this field is only used by mel */
		bat bval;
		batrec br;	/* bval + stamp */
		str sval;
		dbl dval;
		lng lval;
	} val;
	int len, vtype;
} *ValPtr, ValRecord;

#define VALptr(v) (ATOMextern((v)->vtype)?(v)->val.pval:(ptr)&(v)->val.ival)
#define VALnil(v,t) VALset(v,t,ATOMextern(t)?ATOMnil(t):ATOMnilptr(t))

/* interface definitions */
gdk_export ValPtr VALnew(void);
gdk_export ptr VALconvert(int typ, ValPtr t);
gdk_export ptr VALconvert1(int typ, ValPtr src, ValPtr dst);
gdk_export ptr VALconvert2(int typ, ValPtr src, ValPtr dst);
gdk_export int VALformat(char **buf, ValPtr res);
gdk_export int VALprint(stream *fd, ValPtr res);
gdk_export ValPtr VALcopy(ValPtr dst, ValPtr src);
gdk_export ValPtr VALinit(ValPtr d, int tpe, ptr s);
gdk_export void VALempty(ValPtr v);
gdk_export void VALclear(ValPtr v);
gdk_export ValPtr VALset(ValPtr v, int t, ptr p);
gdk_export void *VALget(ValPtr v);





typedef struct {
	chr headtype;		/* type id. */
	chr tailtype;		/* type id. */
	unsigned short headloc;	/* offset into bun. */
	unsigned short tailloc;	/* offset into bun. */
	bit headkey;		/* duplicates allowed? */
	bit tailkey;		/* duplicates allowed? */
	bit headvarsized;	/* varsized(>0) or fixedsized(0). */
	bit tailvarsized;	/* varsized(>0) or fixedsized(0). */
	chr bunshift;		/* log2 of bunwidth */
	unsigned short bunwidth; /* byte-width of BUN array */
	oid hseq;		/* start of dense head sequence */
	oid tseq;		/* start of dense tail sequence */
} Dimensions;

typedef struct {
	MT_Id tid;		/* which thread created it */
	int stamp;		/* BAT recent creation stamp */
	unsigned int
	    copiedtodisk:1,	/* once written */
	    dirty:2,		/* dirty wrt disk? */
	    dirtyflushed:1,	/* was dirty before commt started? */
	    descdirty:1,	/* bat descriptor dirty marker */
	    bunsdirty:1,	/* bun heap dirty marker */
	    lview:1,		/* bat is a *logical* view on parentid */
	    unused:25;		/* value=0 for now */
	chr set;		/* real set semantics */
	chr restricted;		/* access priviliges */
	sht persistence;	/* should the BAT persist on disk? */
	int sharecnt;		/* incoming view count */
	bat parentid;		/* cache id of VIEW parent bat */
	bit map_dirty;		/* new mmap mode present */
	char map_buns;		/* mmap mode for bun heap */
	char map_hheap;		/* mmap mode for head atom heap */
	char map_theap;		/* mmap mode for tail atom heap */
} BATrec;

typedef struct {