gdk_atoms.h

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

#ifndef _GDK_ATOMS_H_
#define _GDK_ATOMS_H_
#include "gdk.h"

#define MAXATOMS	128



#define simple_CMP(x,y,tpe)     (simple_LT(x,y,tpe)?-1:simple_GT(x,y,tpe))
#define simple_EQ(x,y,tpe)      ((*(tpe*) (x)) == (*(tpe*) (y)))
#define simple_LT(x,y,tpe)      ((*(tpe*) (x))  < (*(tpe*) (y)))
#define simple_GT(x,y,tpe)      ((*(tpe*) (x))  > (*(tpe*) (y)))
#define simple_LE(x,y,tpe)      ((*(tpe*) (x)) <= (*(tpe*) (y)))
#define simple_GE(x,y,tpe)      ((*(tpe*) (x)) >= (*(tpe*) (y)))
#define atom_CMP(x,y,id)        (*BATatoms[id].atomCmp)(x,y)
#define atom_EQ(x,y,id)         ((*BATatoms[id].atomCmp)(x,y) == 0)
#define atom_LT(x,y,id)         ((*BATatoms[id].atomCmp)(x,y) < 0)
#define atom_GT(x,y,id)         ((*BATatoms[id].atomCmp)(x,y) > 0)
#define atom_LE(x,y,id)         ((*BATatoms[id].atomCmp)(x,y) <= 0)
#define atom_GE(x,y,id)         ((*BATatoms[id].atomCmp)(x,y) >= 0)
#define simple_HASH(v,tpe,dst)  ((dst) *(tpe *) (v))
#define atom_HASH(v,id,dst)     ((dst) (*BATatoms[id].atomHash)(v))



#define bitStrlen	8
#define chrStrlen	8
#define bteStrlen	8
#define shtStrlen	12
#define intStrlen	24
#if SIZEOF_OID == SIZEOF_INT
#define oidStrlen	24
#else
#define oidStrlen	48
#endif
#if SIZEOF_WRD == SIZEOF_INT
#define wrdStrlen	24
#else
#define wrdStrlen	48
#endif
#if SIZEOF_PTR == SIZEOF_INT
#define ptrStrlen	24
#else
#define ptrStrlen	48
#endif
#define lngStrlen	48
#define fltStrlen	48
#define dblStrlen	96




#ifdef __cplusplus
extern "C" {
#endif
gdk_export int voidFromStr(str src, int *len, void **dst);
gdk_export int voidToStr(str *dst, int *len, void *src);
gdk_export void *voidRead(void *a, stream *s, size_t cnt);
gdk_export int voidWrite(void *a, stream *s, size_t cnt);

gdk_export int lngFromStr(str src, int *len, lng **dst);
gdk_export int lngToStr(str *dst, int *len, lng *src);
gdk_export lng *lngRead(lng *a, stream *s, size_t cnt);
gdk_export int lngWrite(lng *a, stream *s, size_t cnt);
int lngCmp(lng *r, lng *l);
hash_t lngHash(lng *l);

gdk_export int intFromStr(str src, int *len, int **dst);
gdk_export int intToStr(str *dst, int *len, int *src);
gdk_export int *intRead(int *a, stream *s, size_t cnt);
gdk_export int intWrite(int *a, stream *s, size_t cnt);
gdk_export int intCmp(int *r, int *l);
hash_t intHash(int *i);

gdk_export int batFromStr(str src, int *len, bat **dst);
gdk_export int batToStr(str *dst, int *len, bat *src);
gdk_export bat *batRead(bat *a, stream *s, size_t cnt);
gdk_export int batWrite(bat *a, stream *s, size_t cnt);

gdk_export int ptrFromStr(str src, int *len, ptr **dst);
gdk_export int ptrToStr(str *dst, int *len, ptr *src);
gdk_export ptr *ptrRead(ptr *a, stream *s, size_t cnt);
gdk_export int ptrWrite(ptr *a, stream *s, size_t cnt);

gdk_export int bitFromStr(str src, int *len, bit **dst);
gdk_export int bitToStr(str *dst, int *len, bit *src);
gdk_export bit *bitRead(bit *a, stream *s, size_t cnt);
gdk_export int bitWrite(bit *a, stream *s, size_t cnt);

gdk_export int OIDfromStr(str src, int *len, oid **dst);
gdk_export int OIDtoStr(str *dst, int *len, oid *src);
gdk_export oid *oidRead(oid *a, stream *s, size_t cnt);
gdk_export int oidWrite(oid *a, stream *s, size_t cnt);

gdk_export int shtFromStr(str src, int *len, sht **dst);
gdk_export int shtToStr(str *dst, int *len, sht *src);
gdk_export sht *shtRead(sht *a, stream *s, size_t cnt);
gdk_export int shtWrite(sht *a, stream *s, size_t cnt);
int shtCmp(sht *r, sht *l);
hash_t shtHash(sht *s);

gdk_export int bteFromStr(str src, int *len, bte **dst);
gdk_export int bteToStr(str *dst, int *len, bte *src);
gdk_export bte *bteRead(bte *a, stream *s, size_t cnt);
gdk_export int bteWrite(bte *a, stream *s, size_t cnt);
int bteCmp(bte *r, bte *l);
hash_t bteHash(bte *c);

gdk_export int chrFromStr(str src, int *len, chr **dst);
gdk_export int chrToStr(str *dst, int *len, chr *src);
gdk_export chr *chrRead(chr *a, stream *s, size_t cnt);
gdk_export int chrWrite(chr *a, stream *s, size_t cnt);
int chrCmp(chr *r, chr *l);
hash_t chrHash(chr *c);

gdk_export int fltFromStr(str src, int *len, flt **dst);
gdk_export int fltToStr(str *dst, int *len, flt *src);
gdk_export flt *fltRead(flt *a, stream *s, size_t cnt);
gdk_export int fltWrite(flt *a, stream *s, size_t cnt);
int fltCmp(flt *r, flt *l);

gdk_export int dblFromStr(str src, int *len, dbl **dst);
gdk_export int dblToStr(str *dst, int *len, dbl *src);
gdk_export dbl *dblRead(dbl *a, stream *s, size_t cnt);
gdk_export int dblWrite(dbl *a, stream *s, size_t cnt);
int dblCmp(dbl *r, dbl *l);

gdk_export ssize_t GDKstrFromStr(unsigned char *src, unsigned char *dst, ssize_t len);
gdk_export int strFromStr(str src, int *len, str *dst);
gdk_export int strToStr(str *dst, int *len, str src);
gdk_export str strRead(str a, stream *s, size_t cnt);
gdk_export int strWrite(str a, stream *s, size_t cnt);
gdk_export hash_t strHash(str s);
gdk_export void strCleanHash(Heap *hp, int rebuild);
gdk_export var_t strPut(Heap *b, var_t *off, str src);
gdk_export void strHeap(Heap *d, size_t cap);
gdk_export int strLen(const char *s);
gdk_export int strCmp(str l, str r);
gdk_export int strNil(str s);
gdk_export void strHeapConvert(Heap *h, int directon);
gdk_export int strElimDoubles(Heap *h);
gdk_export var_t strLocate(Heap *h, str v);
gdk_export int strCmpNoNil(unsigned char *l, unsigned char *r);

#ifdef __cplusplus
}
#endif


#include <limits.h>		/* for *_MIN and *_MAX */
#include <float.h>		/* for FLT_MAX and DBL_MAX */
#ifndef LLONG_MAX
#ifdef LONGLONG_MAX
#define LLONG_MAX LONGLONG_MAX
#define LLONG_MIN LONGLONG_MIN
#else
#define LLONG_MAX LL_CONSTANT(9223372036854775807)
#define LLONG_MIN (-LL_CONSTANT(9223372036854775807) - LL_CONSTANT(1))
#endif
#endif
#define GDK_bit_max ((bit) 1)
#define GDK_bit_min ((bit) 0)
#define GDK_chr_max ((chr) SCHAR_MAX)
#define GDK_chr_min ((chr) SCHAR_MIN)
#define GDK_bte_max ((bte) SCHAR_MAX)
#define GDK_bte_min ((bte) SCHAR_MIN)
#define GDK_sht_max ((sht) SHRT_MAX)
#define GDK_sht_min ((sht) SHRT_MIN)
#define GDK_int_max INT_MAX
#define GDK_int_min INT_MIN
#define GDK_flt_max ((flt) FLT_MAX)
#define GDK_flt_min (-GDK_flt_max)
#define GDK_lng_max ((lng) LLONG_MAX)
#define GDK_lng_min ((lng) LLONG_MIN)
#define GDK_dbl_max ((dbl) DBL_MAX)
#define GDK_dbl_min (-GDK_dbl_max)
/* GDK_oid_max see below */
#define GDK_oid_min ((oid) 0)

/* representation of the nil */ 
gdk_export const chr chr_nil;
gdk_export const bte bte_nil;
gdk_export const sht sht_nil;
gdk_export const int int_nil;
gdk_export const flt flt_nil;
gdk_export const dbl dbl_nil;
gdk_export const lng lng_nil;
gdk_export const char str_nil[2];

/* derived NIL values - OIDDEPEND */
#define bit_nil	((bit) chr_nil)
#if SIZEOF_VOID_P == SIZEOF_INT
#define ptr_nil	((ptr) int_nil)
#else /* SIZEOF_VOID_P == SIZEOF_LNG */
#define ptr_nil	((ptr) lng_nil)
#endif
#define bat_nil	((bat) int_nil)
#if SIZEOF_WRD == SIZEOF_INT
#define wrd_nil	((wrd) int_nil)
#define GDK_wrd_max ((wrd) GDK_int_max)
#define GDK_wrd_min ((wrd) GDK_int_min)
#else
#define wrd_nil	((wrd) lng_nil)
#define GDK_wrd_max ((wrd) GDK_lng_max)
#define GDK_wrd_min ((wrd) GDK_lng_min)
#endif
#if SIZEOF_OID == SIZEOF_INT
#define oid_nil ((oid) GDK_int_min)
#define GDK_oid_max ((oid) GDK_int_max)
#else
#define oid_nil ((oid) GDK_lng_min)
#define GDK_oid_max ((oid) GDK_lng_max)
#endif

#define void_nil	oid_nil


/* use "do ... while(0)" so that lhs can safely be used in if statements */
#define ATOMstorage(t)		BATatoms[t].storage
#define ATOMsize(t)		BATatoms[t].size
#define ATOMalign(t)		BATatoms[t].align
#define ATOMfromstr(t,s,l,src)	BATatoms[t].atomFromStr(src,l,s)
#define ATOMnilptr(t)		BATatoms[t].atomNull
#define ATOMhash(t,src)		BATatoms[t].atomHash(src)
#define ATOMdel(t,hp,src)	do if (BATatoms[t].atomDel) BATatoms[t].atomDel(hp,src); while (0)
#define ATOMvarsized(t)		((t != TYPE_void) && BATatoms[t].varsized)
#define ATOMlinear(t)		BATatoms[t].linear
#define ATOMtype(t)		((t == TYPE_void)?TYPE_oid:t)
#define ATOMfix(t,v)		do if (BATatoms[t].atomFix) BATatoms[t].atomFix(v); while (0)
#define ATOMunfix(t,v)		do if (BATatoms[t].atomUnfix) BATatoms[t].atomUnfix(v); while (0)
#define ATOMconvert(t,v,d)	do if (BATatoms[t].atomConvert) BATatoms[t].atomConvert(v,d); while (0)
#define ATOMheapConvert(t,hp,d)	do if (BATatoms[t].atomHeapConvert) BATatoms[t].atomHeapConvert(hp,d); while (0)

#define CONV_HTON               1
#define CONV_NTOH               0



#define ATOMput(P1, P2, p3, p4)						\
{									\
	int t_ = (P1);							\
	ptr P3 = (ptr) (p3);						\
	ptr P4 = (ptr) (p4);						\
									\
	if (t_ == TYPE_oid || t_ == TYPE_wrd || t_ == TYPE_ptr || t_ > TYPE_str)		\
		t_ = ATOMstorage(t_);					\
	if (t_ <= TYPE_bat) {						\
		if (t_ <= TYPE_bte) {					\
			if (t_ != TYPE_void)				\
				*(bte *) (P3) = *(bte *) (P4);		\
		} else if (t_ == TYPE_sht) {				\
			*(sht *) (P3) = *(sht *) (P4);			\
		} else if (t_ == TYPE_bat) {				\
			BBPincref(*(bat *) (P4), TRUE);			\
			*(bat *) (P3) = *(bat *) (P4);			\
		}							\
	} else {							\
		if (t_ <= TYPE_flt) {					\
			*(int *) (P3) = *(int *) (P4);			\
		} else if (t_ <= TYPE_lng) {				\
			*(lng *) (P3) = *(lng *) (P4);			\
		} else if (t_ == TYPE_str) {				\
			if (strPut(P2, (var_t *) (P3), (str) (P4)) == 0)\
				goto bunins_failed;			\
		} else if (t_) {					\
			if (BATatoms[t_].atomPut) {			\
				if ((*BATatoms[t_].atomPut) (P2, (var_t *) P3, P4) == 0) \
					goto bunins_failed;		\
			} else {					\
				memcpy(P3, P4, (size_t) ATOMsize(P1));	\
			}						\
			ATOMfix(t_, P4);				\
		}							\
	}								\
}

#define ATOMreplace(P1,	P2, P3, P4)					\
{									\
	int t_ = (P1);							\
									\
	if (t_ == TYPE_oid || t_ == TYPE_wrd || t_ == TYPE_ptr || t_ > TYPE_str)		\
		t_ = ATOMstorage(t_);					\
	if (t_ <= TYPE_bat) {						\
		if (t_ <= TYPE_bte) {					\
			if (t_ != TYPE_void)				\
				*(bte *) (P3) = *(bte *) (P4);		\
		} else if (t_ == TYPE_sht) {				\
			*(sht *) (P3) = *(sht *) (P4);			\
		} else if (t_ == TYPE_bat) {				\
			BBPincref(*(bat *) (P4), TRUE);			\
			BBPdecref(*(bat *) (P3), TRUE);			\
			*(bat *) (P3) = *(bat *) (P4);			\
		}							\
	} else {							\
		if (t_ <= TYPE_flt) {					\
			*(int *) (P3) = *(int *) (P4);			\
		} else if (t_ <= TYPE_lng) {				\
			*(lng *) (P3) = *(lng *) (P4);			\
		} else if (t_ == TYPE_str) {				\
			if (strPut(P2, (var_t *) (P3), (str) (P4)) == 0) \
				goto bunins_failed;			\
		} else if (BATatoms[t_].atomPut) {			\
			var_t loc_ = *(var_t *) (P3);			\
									\
			if ((*BATatoms[t_].atomPut) (P2, &loc_, P4) == 0) \
				goto bunins_failed;			\
			ATOMunfix(t_, P3);				\
			if (BATatoms[t_].atomDel) {			\
				ATOMdel(t_, P2, (var_t *) P3);		\
			}						\
			*(var_t *) (P3) = loc_;				\
			ATOMfix(t_, P4);				\
		} else {						\
			ATOMunfix(t_, P3);				\
			memcpy(P3, P4, (size_t) ATOMsize(P1));		\
			ATOMfix(t_, P4);				\
		}							\
	}								\
}

#define GDK_STRHASHTABLE	(1<<10)
#define GDK_STRHASHMASK		(GDK_STRHASHTABLE-1)
#define GDK_STRHASHSIZE		(GDK_STRHASHTABLE * sizeof(var_t))
#define GDK_STRHASHCREDIT(h)	(((var_t*) (h)->base)[GDK_STRHASHTABLE])
#define GDK_ELIMDOUBLES(h)	((h)->free < GDK_ELIMLIMIT)
#define GDK_ELIMLIMIT		(1<<GDK_ELIMPOWER)
#define GDK_ELIMBASE(x)		(((x) >> GDK_ELIMPOWER) << GDK_ELIMPOWER)
#if SIZEOF_SIZE_T == SIZEOF_INT
#define GDK_ELIMPOWER		16	/* makes for a max 64KB hash table 
					 * ie 256 string bytes per hash bucket 
					 * ~ 4 strings of UP4(8<=len<=11)=12 + 4 bytes 
					 */
#else
#define GDK_ELIMPOWER		17	/* makes for a max 128KB hash table 
					 * ie 512 string bytes per hash bucket 
					 * ~ 5 strings of UP8(8<=len<=15)=16 + 8 bytes 
					 */
#endif



#define GDK_STRNIL(s)    ((s) == NULL || *(chr*) (s) == GDK_chr_min)
#define GDK_STRLEN(s)    ((GDK_STRNIL(s)?1:strlen(s))+1)
#define GDK_STRCMP(l,r)  (GDK_STRNIL(l)?(GDK_STRNIL(r)?0:-1):GDK_STRNIL(r)?1: \
                          (*(unsigned char*)(l) < *(unsigned char*)(r))?-1: \
                          (*(unsigned char*)(l) > *(unsigned char*)(r))?1: \
                          strCmpNoNil((unsigned char*)(l),(unsigned char*)(r)))


#define GDK_STRHASH(x,y) {                                             \
        str _c = (str) (x);                                            \
        for((y)=0; _c[0] && _c[1]; _c+=2) {                            \
                 (y) = ((y) << 3) ^ ((y) >> 11) ^ ((y) >> 17) ^ (_c[1] << 8) ^ _c[0];\
        }                                                              \
        (y) ^= _c[0];                                                  \
}


extern int ATOMunknown_add( str nme );
extern int ATOMunknown_del( int a );
gdk_export int ATOMunknown_find( str nme );
extern str ATOMunknown_name( int a );



#endif /* _GDK_ATOMS_H_ */