gdk_atoms.c

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

		return 3;
	}
	snprintf(*dst, *len, SZFMT, (size_t) *src);
	return (int) strlen(*dst);
}


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


#if SIZEOF_VOID_P == SIZEOF_INT

#line 1561 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
 ptr *ptrRead(ptr *a, stream *s, size_t cnt)
{
	stream_readIntArray(s, (int*)a, cnt);
	return stream_errnr(s) ? NULL : a;
}
int ptrWrite(ptr *a, stream *s, size_t cnt)
{
	return stream_writeIntArray(s, (int*)a, cnt) ? GDK_SUCCEED : GDK_FAIL;
}


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

#else /* SIZEOF_VOID_P == SIZEOF_LNG */

#line 1561 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
 ptr *ptrRead(ptr *a, stream *s, size_t cnt)
{
	stream_readLngArray(s, (lng*)a, cnt);
	return stream_errnr(s) ? NULL : a;
}
int ptrWrite(ptr *a, stream *s, size_t cnt)
{
	return stream_writeLngArray(s, (lng*)a, cnt) ? GDK_SUCCEED : GDK_FAIL;
}


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

#endif

int
dblFromStr(char *src, int *len, dbl **dst)
{
	char *p = src;
	double d;

	/* alloc memory */
	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (dbl *) GDKmalloc(*len = sizeof(dbl));
	} else if (*len < (int) sizeof(dbl)) {
		GDKfree(*dst);
		*dst = (dbl *) GDKmalloc(*len = sizeof(dbl));
	}


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


	/* on overflow, strtod returns HUGE_VAL and sets errno to
	   ERANGE; on underflow, it returns 0 and also sets errno to
	   ERANGE.  We accept 0, but not HUGE_VAL. */
	errno = 0;
	d = strtod(src, &p);
	if (p == src || (errno == ERANGE && d != 0)) {
		**dst = dbl_nil;	/* default return value is nil */
		p = src;
	} else {
		**dst = (dbl) d;
	}
	return (int) (p - src);
}

#line 1096 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
dblToStr(char ** dst, int *len, dbl *src)
{
	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (char *) GDKmalloc(*len = dblStrlen);
	} else if (*len < (int) dblStrlen) {
		GDKfree(*dst);
		*dst = (char *) GDKmalloc(*len = dblStrlen);
	}


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

	if (*src == dbl_nil) {
		strcpy(*dst, "nil");
		return 3;
	}
	snprintf(*dst, *len, "%.17g", (double) *src);
	return (int) strlen(*dst);
}


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


#line 1561 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
 dbl *dblRead(dbl *a, stream *s, size_t cnt)
{
	stream_readLngArray(s, (lng*)a, cnt);
	return stream_errnr(s) ? NULL : a;
}
int dblWrite(dbl *a, stream *s, size_t cnt)
{
	return stream_writeLngArray(s, (lng*)a, cnt) ? GDK_SUCCEED : GDK_FAIL;
}


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


#if defined(HAVE_STRTOF) && !HAVE_DECL_STRTOF
extern float strtof(const char *, char **);
#endif

int
fltFromStr(char *src, int *len, flt **dst)
{
#ifdef HAVE_STRTOF
	char *p = src;
#endif
	int n = 0;
	float f;

	/* alloc memory */
	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (flt *) GDKmalloc(*len = sizeof(flt));
	} else if (*len < (int) sizeof(flt)) {
		GDKfree(*dst);
		*dst = (flt *) GDKmalloc(*len = sizeof(flt));
	}


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


#ifdef HAVE_STRTOF
	/* on overflow, strtof returns HUGE_VALF and sets errno to
	   ERANGE; on underflow, it returns 0 and also sets errno to
	   ERANGE.  We accept 0, but not HUGE_VALF. */
	errno = 0;
	f = strtof(src, &p);
	n = (int) (p - src);
	if (n == 0 || (errno == ERANGE && f != 0)
#ifdef INFINITY
	    || f == INFINITY
#endif
#ifdef NAN
#ifndef __PGI
	    || f == NAN
#endif
#endif
	    )
#else /* no strtof, try sscanf */
	if (sscanf(src, "%f%n", &f, &n) <= 0 || n <= 0
#ifdef INFINITY
	    || f == INFINITY
#endif
#ifdef NAN
#ifndef __PGI
	    || f == NAN
#endif
#endif
	    )
#endif
	{
		**dst = flt_nil;	/* default return value is nil */
		n = 0;
	} else {
		**dst = (flt) f;
	}
	return n;
}


#line 1096 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
fltToStr(char ** dst, int *len, flt *src)
{
	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (char *) GDKmalloc(*len = fltStrlen);
	} else if (*len < (int) fltStrlen) {
		GDKfree(*dst);
		*dst = (char *) GDKmalloc(*len = fltStrlen);
	}


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

	if (*src == flt_nil) {
		strcpy(*dst, "nil");
		return 3;
	}
	snprintf(*dst, *len, "%.9g", (float) *src);
	return (int) strlen(*dst);
}


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


#line 1561 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
 flt *fltRead(flt *a, stream *s, size_t cnt)
{
	stream_readIntArray(s, (int*)a, cnt);
	return stream_errnr(s) ? NULL : a;
}
int fltWrite(flt *a, stream *s, size_t cnt)
{
	return stream_writeIntArray(s, (int*)a, cnt) ? GDK_SUCCEED : GDK_FAIL;
}


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




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



#line 1799 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
strElimDoubles(Heap *h)
{
	return GDK_ELIMDOUBLES(h);
}



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


#line 1828 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
strNil(str s)
{
	return GDK_STRNIL(s);
}

int
strLen(const char *s)
{
	return (int) GDK_STRLEN(s);
}

int
strCmp(str l, str r)
{
	return GDK_STRCMP(l, r);
}

int
strCmpNoNil(unsigned char *l, unsigned char *r)
{
	while (*l == *r) {
		if (*l == 0)
			return 0;
		l++;
		r++;
	}
	return (*l < *r) ? -1 : 1;
}

void
strHeap(Heap *d, size_t cap)
{
	size_t size;
	var_t *h, *e;

	cap = MAX(cap, BATTINY);
	size = (GDK_STRHASHTABLE + 1) * sizeof(var_t) + MIN(GDK_ELIMLIMIT, cap * 12);
	if (HEAPalloc(d, size, 1) >= 0) {
		d->free = GDK_STRHASHTABLE * sizeof(var_t);
		h = (var_t *) d->base;
		for (e = h; e < h + GDK_STRHASHTABLE; e++) {
			*e = 0;
		}
	}
}




#line 1889 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
hash_t
strHash(str s)
{
	hash_t res;
	GDK_STRHASH(s, res);
	return res;
}


void strCleanHash(Heap *h, int rebuild) 
{
        if (!GDK_ELIMDOUBLES(h)) {
                /* flush hash table for security */
	        memset(h->base, 0, GDK_STRHASHSIZE);
	} else if (rebuild) {
                var_t xx, cur=0, end=0;
		str hash = (str) h->base;
/* int cnt[GDK_STRHASHTABLE]; */ 
		/* collect all values in one big linked list */
                for(xx=0; xx<GDK_STRHASHTABLE; xx++) {
                        var_t yy = ((var_t*) hash)[xx];

/* cnt[xx]=0; */
		        ((var_t*) hash)[xx] = 0; /* clear hash table slot */ 

		        if (end) {
                                *(var_t*) (hash + end) = yy;
                        } else {
                                cur = yy;
                        }
		        for(; yy; yy=*(var_t*) (hash + yy)) end = yy;
                }

		/* process the linked list, inserting the values again */
                for(; cur; cur=end) {
                	str val = hash + cur;
                	GDK_STRHASH(val + sizeof(var_t), xx);
                	xx &= GDK_STRHASHMASK;
                        end = *(var_t*) val;
                        *(var_t*) val = ((var_t*) hash)[xx];
                	((var_t*) hash)[xx] = cur;
/* cnt[xx]++; */
        	}
/* for(xx=0; xx<GDK_STRHASHTABLE; xx++)
   if(cnt[xx]) stream_printf(GDKout, "%5d %6d", xx, cnt[xx]); */
        } 
}



#line 1942 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
var_t
strLocate(Heap *h, str v)
{
	var_t *htab = (var_t *) h->base;
	var_t *l, *e;
	hash_t idx;
        GDK_STRHASH(v, idx);
        e = htab + (idx & GDK_STRHASHMASK);
	if (*e) {
		for (l = e; *l && *l < h->free; l = (var_t *) ((char *) h->base + *l)) {
			str x = (str) ((char *) h->base + *l + sizeof(var_t));

			if (GDK_STRCMP(v, x) == 0) {
				return *l + (var_t) sizeof(var_t);
			}
		}
	}
	return 0;
}

/* convert the integers in the implicit hash table structure */
void
strHeapConvert(Heap *h, int dir)
{
	var_t *htab = (var_t *) h->base;
	var_t *l, i, j;

	if (dir == CONV_HTON) {
		for (i = 0; i < GDK_STRHASHTABLE; i++) {
			for (l = htab + i; (j = *l) != 0 && j < h->free; l = (var_t *) (h->base + j)) {
				*l = normal_vart_SWAP(j);
			}
		}
	} else {
		for (i = 0; i < GDK_STRHASHTABLE; i++) {
			for (l = htab + i; (j = *l) != 0 && j < h->free; l = (var_t *) (h->base + *l)) {
				*l = normal_vart_SWAP(j);
			}
		}
	}
}

var_t
strPut(Heap *h, var_t *dst, str v)
{
	var_t *l;
	size_t i = GDK_STRLEN(v);
	hash_t off;

	/* round up to var_t-byte alignment + var_t (next pointer) */
	size_t len = ((i + sizeof(var_t) - 1) & ~(sizeof(var_t) - 1)) + sizeof(var_t);
	size_t elimlimit = GDK_ELIMBASE(h->free) + GDK_ELIMLIMIT;

	/* search hash-table, if double-elimination is still in place */
	GDK_STRHASH(v,off);
	off &= GDK_STRHASHMASK;
	for (l = ((var_t *) h->base) + off; *l && *l < h->free; l = (var_t *) (h->base + *l)) {
		str x = (str) (h->base + *l + sizeof(var_t));

		if (GDK_STRCMP(v, x) == 0) {
			*dst = *l + (var_t) sizeof(var_t);	/* already in heap; do not insert! */
        		if (GDK_ELIMDOUBLES(h) == 0 && GDK_STRHASHCREDIT(h)) GDK_STRHASHCREDIT(h) += 4;
			return *dst;
		}
	}

	/* flush the hash table if it becomes too big (implies !GDK_ELIMDOUBLES) */
	if (h->free + len >= elimlimit) {
                /* if we are not hash-inserting anymore, h->free may no longer be var_t aligned */
                int mask = h->free & (sizeof(var_t)-1); 
                if (mask) h->free += sizeof(var_t) - mask; /* realign */
	       	memset(h->base, 0, GDK_STRHASHSIZE); /* start over hash inserting in a pristine hash table */
		GDK_STRHASHCREDIT(h) = 32; /* only tolerate limited misses in the future */
	}

	/* check heap for space (limited to a certain maximum after which nils are inserted) */
	if (h->free + len >= h->size) {
		/* Something really strange happens here, In a special case
		   (Pentium II Klamath, gcc version 2.96 20000731,
		   GNU assembler version 2.10.90 using BFD version 2.10.0.18)
		   the fldl instruction to load BATMARGIN goes SOMETIMES
		   (but reproducable) wrong (the register is filled with
		   -NaN iso 1.5 (BATMARGIN)). So replaced this code:
		   size_t newsize = len + h->size * BATMARGIN;
		 */
		float batmargin = (float) BATMARGIN;
		float hnewsize = h->size * batmargin;
		size_t newsize = len + (size_t) hnewsize;

		assert(newsize);

		if (h->free + len < h->maxsize) {
			/* if there is reserved space, first use the reserved space */
			newsize = MIN(newsize, h->maxsize);
		}
		if (HEAPextend(h, newsize) < 0) {
			return 0;
		}
		/* fill should solve initialisation problems within valgrind */
                memset(h->base+h->free, 0, h->size-h->free);
	}

        if (!GDK_ELIMDOUBLES(h)) {
                if (GDK_STRHASHCREDIT(h) == 0) { 
                        /* if credits are gone, we do not hash insert at all */
			memcpy(h->base + (*dst = h->free), v, i);
	                h->free += i; /* in this case, we do not round to var_t either */ 
			return *dst;
                }
		GDK_STRHASHCREDIT(h)--;
	} 

	/* insert string in hash table and copy into the heap */
	l = (var_t *) (h->base + h->free);
	*(l++) = ((var_t *) h->base)[off];
	((var_t *) h->base)[off] = h->free;
        *dst = h->free + sizeof(var_t);
	h->free += len;
	memcpy((char *) l, v, i);

	return *dst;
}



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

/*
   UTF-8 encoding is as follows:
U-00000000 - U-0000007F: 0xxxxxxx
U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
U-04000000 - U-7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
*/
/* To be correctly coded UTF-8, the sequence should be the shortest
   possible encoding of the value being encoded.  This means that for
   an encoding of length n+1 (1 <= n <= 5), at least one of the bits in
   utf8chkmsk[n] should be non-zero (else the encoding could be
   shorter).
*/
static int utf8chkmsk[] = {
	0x0000007f,
	0x00000780,
	0x0000f800,
	0x001f0000,
	0x03e00000,
	0x7c000000,
};

ssize_t
GDKstrFromStr(unsigned char *dst, unsigned char *src, ssize_t len)
{
	unsigned char *p = dst, *cur = src, *end = src + len;
	int escaped = FALSE, mask = 0, n, c, utf8char = 0;

	/* copy it in, while performing the correct escapes */
	/* n is the number of follow-on bytes left in a multi-byte
	   UTF-8 sequence */
	for (cur = src, n = 0; cur < end || escaped; cur++) {
		/* first convert any \ escapes and store value in c */
		if (escaped) {
			switch (*cur) {
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
				/* \ with up to three octal digits */
				c = base08(*cur);
				if (num08(cur[1])) {
					cur++;
					c = mult08(c) + base08(*cur);
					if (num08(cur[1])) {
						cur++;
						c = mult08(c) + base08(*cur);
						/* if three digits, only look at lower 8 bits */
						c &= 0377;
					}