gdk_atoms.c

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

#line 186 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
#include "monetdb_config.h"
#include "gdk.h"
#include <math.h>		/* for INFINITY and NAN */

int
chrCmp(chr *l, chr *r)
{
	return simple_CMP(l, r, chr);
}

int
bteCmp(bte *l, bte *r)
{
	return simple_CMP(l, r, bte);
}

int
shtCmp(sht *l, sht *r)
{
	return simple_CMP(l, r, sht);
}

int
intCmp(int *l, int *r)
{
	return simple_CMP(l, r, int);
}

int
fltCmp(flt *l, flt *r)
{
	return simple_CMP(l, r, flt);
}

int
lngCmp(lng *l, lng *r)
{
	return simple_CMP(l, r, lng);
}

int
dblCmp(dbl *l, dbl *r)
{
	return simple_CMP(l, r, dbl);
}



#line 235 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
hash_t
chrHash(chr *v)
{
	return (hash_t) *(unsigned char *) v;
}

hash_t
bteHash(bte *v)
{
	return (hash_t) *(unsigned char *) v;
}

hash_t
shtHash(sht *v)
{
	return (hash_t) mix_sht(*(unsigned short *) v);
}

hash_t
intHash(int *v)
{
	return (hash_t) mix_int(*(unsigned int *) v);
}

hash_t
lngHash(lng *v)
{
	return (hash_t) mix_int(((unsigned int *) v)[0] ^ ((unsigned int *) v)[1]);
}



#line 267 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
static INLINE void
shtConvert(sht *s)
{
	*s = short_int_SWAP(*s);
}
static INLINE void
intConvert(int *s)
{
	*s = normal_int_SWAP(*s);
}
static INLINE void
lngConvert(lng *s)
{
	*s = long_long_SWAP(*s);
}
static INLINE int
batFix(bat *b)
{
	return BBPincref(*b, TRUE);
}
static INLINE int
batUnfix(bat *b)
{
	return BBPdecref(*b, TRUE);
}

atomDesc BATatoms[MAXATOMS] = {
	{"void",
#if SIZEOF_OID == SIZEOF_INT
	 TYPE_void, 1, 0, /* sizeof(void) */ 0, 0, 1, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) OIDfromStr, (int (*)(str *, int *, ptr)) OIDtoStr,
	 (void *(*)(void *, stream *, size_t)) voidRead, (int (*)(void *, stream *, size_t)) voidWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, 0,
#else
	 TYPE_void, 1, 0, /* sizeof(void) */ 0, 0, 1, (ptr) &lng_nil,
	 (int (*)(str, int *, ptr *)) OIDfromStr, (int (*)(str *, int *, ptr)) OIDtoStr,
	 (void *(*)(void *, stream *, size_t)) voidRead, (int (*)(void *, stream *, size_t)) voidWrite,
	 (int (*)(ptr, ptr)) lngCmp,
	 (hash_t (*)(ptr)) lngHash, 0,
#endif
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"bit", TYPE_chr, 1, sizeof(bit), sizeof(bit), 0, 0, (ptr) &chr_nil,
	 (int (*)(str, int *, ptr *)) bitFromStr, (int (*)(str *, int *, ptr)) bitToStr,
	 (void *(*)(void *, stream *, size_t)) bitRead, (int (*)(void *, stream *, size_t)) bitWrite,
	 (int (*)(ptr, ptr)) chrCmp,
	 (hash_t (*)(ptr)) chrHash, 0,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"chr", TYPE_chr, 1, sizeof(chr), sizeof(chr), 0, 0, (ptr) &chr_nil,
	 (int (*)(str, int *, ptr *)) chrFromStr, (int (*)(str *, int *, ptr)) chrToStr,
	 (void *(*)(void *, stream *, size_t)) chrRead, (int (*)(void *, stream *, size_t)) chrWrite,
	 (int (*)(ptr, ptr)) chrCmp,
	 (hash_t (*)(ptr)) chrHash, 0,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"bte", TYPE_bte, 1, sizeof(bte), sizeof(bte), 0, 0, (ptr) &bte_nil,
	 (int (*)(str, int *, ptr *)) bteFromStr, (int (*)(str *, int *, ptr)) bteToStr,
	 (void *(*)(void *, stream *, size_t)) bteRead, (int (*)(void *, stream *, size_t)) bteWrite,
	 (int (*)(ptr, ptr)) bteCmp,
	 (hash_t (*)(ptr)) bteHash, 0,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"sht", TYPE_sht, 1, sizeof(sht), sizeof(sht), 0, 0, (ptr) &sht_nil,
	 (int (*)(str, int *, ptr *)) shtFromStr, (int (*)(str *, int *, ptr)) shtToStr,
	 (void *(*)(void *, stream *, size_t)) shtRead, (int (*)(void *, stream *, size_t)) shtWrite,
	 (int (*)(ptr, ptr)) shtCmp,
	 (hash_t (*)(ptr)) shtHash, (void (*)(ptr, int)) shtConvert,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"BAT", TYPE_int, 1, sizeof(bat), sizeof(bat), 0, 0, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) batFromStr, (int (*)(str *, int *, ptr)) batToStr,
	 (void *(*)(void *, stream *, size_t)) batRead, (int (*)(void *, stream *, size_t)) batWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
	 (int (*)(ptr)) batFix, (int (*)(ptr)) batUnfix,
	 0, 0,
	 0, 0,
	 0, 0},
	{"int", TYPE_int, 1, sizeof(int), sizeof(int), 0, 0, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) intFromStr, (int (*)(str *, int *, ptr)) intToStr,
	 (void *(*)(void *, stream *, size_t)) intRead, (int (*)(void *, stream *, size_t)) intWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"oid",
#if SIZEOF_OID == SIZEOF_INT
	 TYPE_int, 1, sizeof(oid), sizeof(oid), 0, 0, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) OIDfromStr, (int (*)(str *, int *, ptr)) OIDtoStr,
	 (void *(*)(void *, stream *, size_t)) intRead, (int (*)(void *, stream *, size_t)) intWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
#else
	 TYPE_lng, 1, sizeof(oid), sizeof(oid), 0, 0, (ptr) &lng_nil,
	 (int (*)(str, int *, ptr *)) OIDfromStr, (int (*)(str *, int *, ptr)) OIDtoStr,
	 (void *(*)(void *, stream *, size_t)) lngRead, (int (*)(void *, stream *, size_t)) lngWrite,
	 (int (*)(ptr, ptr)) lngCmp,
	 (hash_t (*)(ptr)) lngHash, (void (*)(ptr, int)) lngConvert,
#endif
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"wrd",
#if SIZEOF_WRD == SIZEOF_INT
	 TYPE_int, 1, sizeof(wrd), sizeof(wrd), 0, 0, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) intFromStr, (int (*)(str *, int *, ptr)) intToStr,
	 (void *(*)(void *, stream *, size_t)) intRead, (int (*)(void *, stream *, size_t)) intWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
#else
	 TYPE_lng, 1, sizeof(wrd), sizeof(wrd), 0, 0, (ptr) &lng_nil,
	 (int (*)(str, int *, ptr *)) lngFromStr, (int (*)(str *, int *, ptr)) lngToStr,
	 (void *(*)(void *, stream *, size_t)) lngRead, (int (*)(void *, stream *, size_t)) lngWrite,
	 (int (*)(ptr, ptr)) lngCmp,
	 (hash_t (*)(ptr)) lngHash, (void (*)(ptr, int)) lngConvert,
#endif
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"ptr",
#if SIZEOF_VOID_P == SIZEOF_INT
	 TYPE_int, 1, sizeof(ptr), sizeof(ptr), 0, 0, (ptr) &int_nil,
	 (int (*)(str, int *, ptr *)) ptrFromStr, (int (*)(str *, int *, ptr)) ptrToStr,
	 (void *(*)(void *, stream *, size_t)) ptrRead, (int (*)(void *, stream *, size_t)) ptrWrite,
	 (int (*)(ptr, ptr)) intCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
#else /* SIZEOF_VOID_P == SIZEOF_LNG */
	 TYPE_lng, 1, sizeof(ptr), sizeof(ptr), 0, 0, (ptr) &lng_nil,
	 (int (*)(str, int *, ptr *)) ptrFromStr, (int (*)(str *, int *, ptr)) ptrToStr,
	 (void *(*)(void *, stream *, size_t)) ptrRead, (int (*)(void *, stream *, size_t)) ptrWrite,
	 (int (*)(ptr, ptr)) lngCmp,
	 (hash_t (*)(ptr)) lngHash, (void (*)(ptr, int)) lngConvert,
#endif
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"flt", TYPE_flt, 1, sizeof(flt), sizeof(flt), 0, 0, (ptr) &flt_nil,
	 (int (*)(str, int *, ptr *)) fltFromStr, (int (*)(str *, int *, ptr)) fltToStr,
	 (void *(*)(void *, stream *, size_t)) fltRead, (int (*)(void *, stream *, size_t)) fltWrite,
	 (int (*)(ptr, ptr)) fltCmp,
	 (hash_t (*)(ptr)) intHash, (void (*)(ptr, int)) intConvert,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"dbl", TYPE_dbl, 1, sizeof(dbl), sizeof(dbl), 0, 0, (ptr) &dbl_nil,
	 (int (*)(str, int *, ptr *)) dblFromStr, (int (*)(str *, int *, ptr)) dblToStr,
	 (void *(*)(void *, stream *, size_t)) dblRead, (int (*)(void *, stream *, size_t)) dblWrite,
	 (int (*)(ptr, ptr)) dblCmp,
	 (hash_t (*)(ptr)) lngHash, (void (*)(ptr, int)) lngConvert,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"lng", TYPE_lng, 1, sizeof(lng), sizeof(lng), 0, 0, (ptr) &lng_nil,
	 (int (*)(str, int *, ptr *)) lngFromStr, (int (*)(str *, int *, ptr)) lngToStr,
	 (void *(*)(void *, stream *, size_t)) lngRead, (int (*)(void *, stream *, size_t)) lngWrite,
	 (int (*)(ptr, ptr)) lngCmp,
	 (hash_t (*)(ptr)) lngHash, (void (*)(ptr, int)) lngConvert,
	 0, 0,
	 0, 0,
	 0, 0,
	 0, 0},
	{"str", TYPE_str, 1, sizeof(var_t), sizeof(var_t), 0, 1, (ptr) str_nil,
	 (int (*)(str, int *, ptr *)) strFromStr, (int (*)(str *, int *, ptr)) strToStr,
	 (void *(*)(void *, stream *, size_t)) strRead, (int (*)(void *, stream *, size_t)) strWrite,
	 (int (*)(ptr, ptr)) strCmp,
	 (hash_t (*)(ptr)) strHash, 0,
	 0, 0,
	 (var_t (*)(Heap *, var_t *, ptr)) strPut, 0,
	 (int (*)(ptr)) strLen, strHeap,
	 (void (*)(Heap *, int)) strHeapConvert, 0},
};
int GDKatomcnt = TYPE_str + 1;



#line 500 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
void
ATOMdelete(int id)
{
	memset(BATatoms + id, 0, sizeof(atomDesc));

	if (id == GDKatomcnt - 1)
		GDKatomcnt--;
}

static int
align(int n)
{
	if (n == 0)
		return 0;
	/* successively check bits from the bottom to see if one is set */
	if (n & 1)
		return 1;
	if (n & 2)
		return 2;
	if (n & 4)
		return 4;
	return 8;
}

void
ATOMproperty(str id, str property, GDKfcn arg)
{
	int t;

	gdk_set_lock(GDKthreadLock, "ATOMproperty");
	t = ATOMindex(id);

	if (t < 0) {
		t = -t;
		if (t == GDKatomcnt) {
			GDKatomcnt++;
		}
		FATALcheck(GDKatomcnt == MAXATOMS, "ATOMproperty:too many types");
		FATALcheck(strlen(id) >= IDLENGTH, "ATOMproperty:name too long");
		memset(BATatoms + t, 0, sizeof(atomDesc));
		strcpy(BATatoms[t].name, id);
		BATatoms[t].size = sizeof(int);	/* default */
		BATatoms[t].align = sizeof(int);	/* default */
		BATatoms[t].linear = 1;	/* default */
		BATatoms[t].storage = t;	/* default */
		BATatoms[t].deleting = 1;	/* not yet usable */
	}
	if (strcmp("size", property) == 0) {
		if ((int) (ssize_t) arg) {
			BATatoms[t].size = (int) (ssize_t) arg;
			BATatoms[t].varsized = 0;
			BATatoms[t].align = align((int) (ssize_t) arg);
		} else {
			BATatoms[t].size = sizeof(var_t);
			BATatoms[t].varsized = 1;
			BATatoms[t].align = sizeof(var_t);
		}
	} else if (strcmp("linear", property) == 0) {
		BATatoms[t].linear = (int) (ssize_t) arg;
	} else if (strcmp("align", property) == 0) {
		BATatoms[t].align = (int) (ssize_t) arg;
	} else if (strcmp("storage", property) == 0) {
		int tpe = (int) (ssize_t) arg;

		BATatoms[t] = BATatoms[tpe];	/* copy from example */
		strcpy(BATatoms[t].name, id);	/* restore name */
	} else if (strcmp("fromstr", property) == 0) {
		BATatoms[t].atomFromStr = (int (*)(char *, int *, void **)) arg;
	} else if (strcmp("tostr", property) == 0) {
		BATatoms[t].atomToStr = (int (*)(char **, int *, void *)) arg;
	} else if (strcmp("read", property) == 0) {
		BATatoms[t].atomRead = (void *(*)(void *, stream *, size_t)) arg;
	} else if (strcmp("write", property) == 0) {
		BATatoms[t].atomWrite = (int (*)(void *, stream *, size_t)) arg;
	} else if (strcmp("fix", property) == 0) {
		BATatoms[t].atomFix = (int (*)(void *)) arg;
	} else if (strcmp("unfix", property) == 0) {
		BATatoms[t].atomUnfix = (int (*)(void *)) arg;
	} else {
#define atomset(dst,val) oldval = (ptr) dst; if (val == NULL || dst == val) goto out; dst = val;
		ptr oldval = NULL;

		if (strcmp("heap", property) == 0) {
			BATatoms[t].size = sizeof(var_t);
			BATatoms[t].varsized = 1;
			BATatoms[t].align = sizeof(var_t);
			atomset(BATatoms[t].atomHeap, (void (*)(Heap *, size_t)) arg);
		} else if (strcmp("heapconvert", property) == 0) {
			atomset(BATatoms[t].atomHeapConvert, (void (*)(Heap *, int)) arg);
		} else if (strcmp("check", property) == 0) {
			atomset(BATatoms[t].atomHeapCheck, (int (*)(Heap *, HeapRepair *)) arg);
		} else if (strcmp("del", property) == 0) {
			atomset(BATatoms[t].atomDel, (void (*)(Heap *, var_t *)) arg);
		} else if (strcmp("convert", property) == 0) {
			atomset(BATatoms[t].atomConvert, (void (*)(void *, int)) arg);
		} else if (strcmp("put", property) == 0) {
			atomset(BATatoms[t].atomPut, (var_t (*)(Heap *, var_t *, void *)) arg);
		} else if (strcmp("null", property) == 0) {
			ptr atmnull = ((ptr (*)(void)) arg) ();

			atomset(BATatoms[t].atomNull, atmnull);
		}
		if (oldval)
			goto out;

		/* these ADT functions *must* be equal for overloaded types */
		if (strcmp("cmp", property) == 0) {
			atomset(BATatoms[t].atomCmp, (int (*)(void *, void *)) arg);
		} else if (strcmp("hash", property) == 0) {
			atomset(BATatoms[t].atomHash, (hash_t (*)(void *)) arg);
		} else if (strcmp("length", property) == 0) {
			atomset(BATatoms[t].atomLen, (int (*)(void *)) arg);
		}
		if (BATatoms[t].storage != t)
			GDKerror("ATOMproperty: %s overload of %s violates inheritance from %s.\n", ATOMname(t), property, ATOMname(BATatoms[t].storage));
/*
*/
		BATatoms[t].storage = t;	/* critical redefine: undo remapping */
	}
  out:
	gdk_unset_lock(GDKthreadLock, "ATOMproperty");
}

int
ATOMindex(str nme)
{
	int t, j = GDKatomcnt;

	for (t = 0; t < GDKatomcnt; t++) {
		if (!BATatoms[t].name[0]) {
			if (j == GDKatomcnt)
				j = t;
		} else if (strcmp(nme, BATatoms[t].name) == 0) {
			return t;
		}

	}
	if (strcmp(nme, "bat") == 0) {
		return TYPE_bat;
	}
	return -j;
}

char *
ATOMname(int t)
{
	return (t >= 0 && t < GDKatomcnt && BATatoms[t].name) ? BATatoms[t].name : "null";
}

int
ATOMisdescendant(int tpe, int parent)
{
	int cur = -1;

	while (cur != tpe) {
		cur = tpe;
		if (cur == parent)
			return TRUE;
		tpe = BATatoms[tpe].storage;
	}
	return FALSE;
}

int
ATOMdump(void)
{
	int t;

	for (t = 0; t < GDKatomcnt; t++) {
		stream_printf(GDKout, "%2d '%9s' (%3d) ", t, BATatoms[t].name, BATatoms[t].size);
		if (BATatoms[t].atomFromStr) {
			stream_printf(GDKout, "\"FromStr\" ");
		}
		if (BATatoms[t].atomToStr) {
			stream_printf(GDKout, "\"ToStr\" ");
		}
		if (BATatoms[t].atomCmp) {
			stream_printf(GDKout, "\"Cmp\" ");
		}
		if (BATatoms[t].atomNull) {
			stream_printf(GDKout, "\"Null\" ");
		}
		if (BATatoms[t].atomHash) {
			stream_printf(GDKout, "\"Hash\" ");
		}
		if (BATatoms[t].atomPut) {
			stream_printf(GDKout, "\"Put\" ");
		}
		if (BATatoms[t].atomDel) {
			stream_printf(GDKout, "\"Del\" ");
		}
		if (BATatoms[t].atomLen) {
			stream_printf(GDKout, "\"Len\" ");
		}
		if (BATatoms[t].atomConvert) {
			stream_printf(GDKout, "\"Convert\" ");
		}
		if (BATatoms[t].atomHeap) {
			stream_printf(GDKout, "\"NewHeap\" ");
		}
		stream_printf(GDKout, "\n");
	}
	return 0;
}



#line 706 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"



#line 781 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
const chr chr_nil = (chr) '\200';
const bte bte_nil = GDK_bte_min;
const sht sht_nil = GDK_sht_min;
const int int_nil = GDK_int_min;
const flt flt_nil = GDK_flt_min;
const dbl dbl_nil = GDK_dbl_min;
const lng lng_nil = GDK_lng_min;
const char str_nil[2] = { GDK_chr_min, 0 };

ptr
ATOMnil(int t)
{
	ptr src = ATOMnilptr(t);
	int len = ATOMlen(ATOMtype(t), src);
	ptr dst = GDKmalloc(len);

	memcpy(dst, src, len);
	return dst;
}



#line 802 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


#line 963 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
ATOMlen(int t, ptr src)
{
	int (*l)(ptr) = BATatoms[t].atomLen;

	return l ? (*l)(src) : ATOMsize(t);
}

int
ATOMheap(int t, Heap *hp, size_t cap)
{
	void (*h) (Heap *, size_t) = BATatoms[t].atomHeap;

	if (h) {
		(*h) (hp, cap);
		if (hp->base == NULL)
			return -1;