gdk_value.c

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

#line 50 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
#include "monetdb_config.h"
#include "gdk.h"

ValPtr
VALnew(void)
{
	ValPtr v = (ValPtr) GDKmalloc(sizeof(ValRecord));

	VALempty(v);
	return v;
}

ValPtr
VALset(ValPtr v, int t, ptr p)
{
	switch (ATOMstorage(v->vtype = t)) {
	case TYPE_chr:
		v->val.cval[0] = *(chr *) p;
		v->val.cval[1] = 0;
		v->val.cval[2] = 0;
		v->val.cval[3] = 0;
		break;
	case TYPE_bte:
		v->val.btval = *(bte *) p;
		break;
	case TYPE_sht:
		v->val.shval = *(sht *) p;
		break;
	case TYPE_int:
		v->val.ival = *(int *) p;
		break;
	case TYPE_flt:
		v->val.fval = *(flt *) p;
		break;
	case TYPE_dbl:
		v->val.dval = *(dbl *) p;
		break;
	case TYPE_lng:
		v->val.lval = *(lng *) p;
		break;
	default:
		v->val.pval = p;
		v->len = ATOMlen(t, p);
	}
	return v;
}

void *
VALget(ValPtr v)
{
	switch (ATOMstorage(v->vtype)) {
	case TYPE_chr:
		return (void *) &v->val.cval[0];
	case TYPE_bte:
		return (void *) &v->val.btval;
	case TYPE_sht:
		return (void *) &v->val.shval;
	case TYPE_void:
	case TYPE_int:
		return (void *) &v->val.ival;
	case TYPE_flt:
		return (void *) &v->val.fval;
	case TYPE_dbl:
		return (void *) &v->val.dval;
	case TYPE_lng:
		return (void *) &v->val.lval;
	case TYPE_str:
		return (void *) v->val.pval;
	}
	return NULL;
}

void
VALclear(ValPtr v)
{
	if (v->vtype == TYPE_str || ATOMextern(v->vtype)) {
		if (v->val.pval && v->val.pval != str_nil)
			GDKfree(v->val.pval);
	}
	VALempty(v);
}

void
VALempty(ValPtr v)
{
	v->len = 0;
	v->val.oval = oid_nil;
	v->vtype = TYPE_void;
}

ValPtr
VALcopy(ValPtr d, ValPtr s)
{
	if (!ATOMextern(s->vtype)) {
		*d = *s;
	} else if (s->val.pval == 0) {
		d->val.pval = ATOMnil(s->vtype);
		d->vtype = s->vtype;
	} else if (s->vtype == TYPE_str) {
		d->vtype = TYPE_str;
		d->val.sval = GDKstrdup(s->val.sval);
		d->len = strLen(d->val.sval);
	} else if (s->vtype == TYPE_bit) {
		d->vtype = s->vtype;
		d->len = 1;
		d->val.cval[0] = s->val.cval[0];
	} else {
		ptr p = s->val.pval;

		d->vtype = s->vtype;
		d->len = ATOMlen(d->vtype, p);
		d->val.pval = GDKmalloc(d->len);
		memcpy(d->val.pval, p, d->len);
	}
	return d;
}

ValPtr
VALinit(ValPtr d, int tpe, ptr s)
{
	if (ATOMextern(tpe) == 0) {
		d->vtype = tpe;
		memcpy(&d->val.ival, s, ATOMlen(tpe, s));
	} else if (s == 0) {
		GDKerror("VALinit:unsupported init\n");
		d->vtype = TYPE_int;
	} else if (tpe >= TYPE_str && ATOMstorage(tpe) == TYPE_str) {
		d->vtype = TYPE_str;
		d->val.sval = GDKstrdup(s);
		d->len = strLen(s);
	} else {
		d->vtype = tpe;
		d->len = ATOMlen(tpe, s);
		d->val.pval = GDKmalloc(d->len);
		memcpy(d->val.pval, s, d->len);
	}
	return d;
}



#line 193 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
int
VALprint(stream *s, ValPtr res)
{
	int t = ATOMstorage(res->vtype);

	return ATOMprint(t, VALptr(res), s);
}


int
VALformat(char **buf, ValPtr res)
{
	int t = res->vtype;

	*buf = 0;
	return ATOMformat(t, VALptr(res), buf);
}



#line 270 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
/* convert value in src and store in dst
   does not destroy src, but src and dst are allowed to point to the
   same location if the caller knows that that won't do any harm */
ptr
VALconvert1(int typ, ValPtr src, ValPtr dst)
{
	int orig_src_tpe = src->vtype, src_tpe = src->vtype, dst_tpe = typ;
	ptr p;			/* what's going to be returned (may change for BATs */

	/* use base types for user types */
	if (src_tpe > TYPE_str)
		src_tpe = ATOMstorage(src_tpe);
	if (dst_tpe > TYPE_str)
		dst_tpe = ATOMstorage(dst_tpe);

	if (src != dst)
		*dst = *src;	/* copy already in case there is no conversion */

	/* we saved the original value of src->vtype, so we can
	   overwrite that (in case src==dst */
	dst->vtype = typ;
	p = VALptr(dst);

	if (src_tpe != dst_tpe && orig_src_tpe != typ && dst_tpe != TYPE_void) {
		if (src_tpe >= TYPE_str || dst_tpe >= TYPE_str) {
			if (ATOMcmp(src_tpe, ATOMnilptr(src_tpe), VALptr(src)) == 0) {
				VALset(dst, dst_tpe, ATOMnil(dst_tpe));
			} else {
				return ILLEGALVALUE;
			}
		} else if ((orig_src_tpe == TYPE_bat && src->val.bval == 0) ||
			   ATOMcmp(src_tpe, ATOMnilptr(src_tpe), VALptr(src)) == 0) {
			/* dst_tpe is a built-in type, so VALptr(dst) (p) points to valid memory */
			memcpy(p, ATOMnilptr(dst_tpe), ATOMsize(dst_tpe));
		} else {
			switch (dst_tpe) {
			case TYPE_bat:
			{
				bat bid = (bat) 0;

				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					if (ABS(src->val.cval[0]) <= BBPsize)
						bid = (bat) src->val.cval[0];
					break;
				case TYPE_bte:
					if (ABS(src->val.btval) <= BBPsize)
						bid = (bat) src->val.btval;
					break;
				case TYPE_sht:
					if (ABS(src->val.shval) <= BBPsize)
						bid = (bat) src->val.shval;
					break;
				case TYPE_int:
					if (ABS(src->val.ival) <= BBPsize)
						bid = (bat) src->val.ival;
					break;
				case TYPE_oid:
					if (ABS(src->val.oval) <= BBPsize)
						bid = (bat) src->val.oval;
					break;
				case TYPE_wrd:
					if (ABS(src->val.wval) <= BBPsize)
						bid = (bat) src->val.wval;
					break;
				case TYPE_lng:
					if (ABS(src->val.lval) <= BBPsize)
						bid = (bat) src->val.lval;
					break;
				case TYPE_flt:
					if (ABS(src->val.fval) <= BBPsize)
						bid = (bat) src->val.fval;
					break;
				case TYPE_dbl:
					if (ABS(src->val.dval) <= BBPsize)
						bid = (bat) src->val.dval;
					break;
				}
				if (bid == 0 || !BBPvalid(bid)) {
					return ILLEGALVALUE;
				}
				dst->val.bval = bid;
				p = &dst->val.bval;
				break;
			}
			case TYPE_bit:
				/* bits are funny: true iff value != 0 */
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.cval[0] = (src->val.cval[0] != 0);
					break;
				case TYPE_bte:
					dst->val.cval[0] = (src->val.btval != 0);
					break;
				case TYPE_sht:
					dst->val.cval[0] = (src->val.shval != 0);
					break;
				case TYPE_int:
					dst->val.cval[0] = (src->val.ival != 0);
					break;
				case TYPE_bat:
					dst->val.cval[0] = (src->val.bval != 0);
					break;
				case TYPE_oid:
					dst->val.cval[0] = (src->val.oval != 0);
					break;
				case TYPE_wrd:
					dst->val.cval[0] = (src->val.wval != 0);
					break;
				case TYPE_lng:
					dst->val.cval[0] = (src->val.lval != 0);
					break;
				case TYPE_flt:
					dst->val.cval[0] = (src->val.fval != 0);
					break;
				case TYPE_dbl:
					dst->val.cval[0] = (src->val.dval != 0);
					break;
				}
				break;
			case TYPE_chr:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.cval[0] = (chr) src->val.cval[0];
					break;
				case TYPE_bte:
					dst->val.cval[0] = (chr) src->val.btval;
					break;
				case TYPE_sht:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.shval < (lng) GDK_chr_min || (lng) src->val.shval > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.shval


#line 402 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_int:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.ival < (lng) GDK_chr_min || (lng) src->val.ival > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.ival


#line 405 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_bat:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.bval < (lng) GDK_chr_min || (lng) src->val.bval > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.bval


#line 408 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_oid:
					dst->val.cval[0] = 
#line 221 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	/* when converting from oid, there's no need to compare to GDK_chr_min,
	 * since source value is unsigned (i.e. >= 0) and all GDK_*_min values
	 * are <= 0 (in fact, compilers may warn about the test) */
	((lng) src->val.oval > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.oval


#line 411 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_wrd:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.wval < (lng) GDK_chr_min || (lng) src->val.wval > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.wval


#line 414 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_lng:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.lval < (lng) GDK_chr_min || (lng) src->val.lval > (lng) GDK_chr_max) ? chr_nil : (chr) src->val.lval


#line 417 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_flt:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((dbl) src->val.fval < (dbl) GDK_chr_min || (dbl) src->val.fval > (dbl) GDK_chr_max) ? chr_nil : (chr) src->val.fval


#line 420 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_dbl:
					dst->val.cval[0] = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((dbl) src->val.dval < (dbl) GDK_chr_min || (dbl) src->val.dval > (dbl) GDK_chr_max) ? chr_nil : (chr) src->val.dval


#line 423 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				}
				break;
			case TYPE_bte:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.btval = (bte) src->val.cval[0];
					break;
				case TYPE_bte:
					dst->val.btval = (bte) src->val.btval;
					break;
				case TYPE_sht:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.shval < (lng) GDK_bte_min || (lng) src->val.shval > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.shval


#line 437 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_int:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.ival < (lng) GDK_bte_min || (lng) src->val.ival > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.ival


#line 440 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_bat:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.bval < (lng) GDK_bte_min || (lng) src->val.bval > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.bval


#line 443 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_oid:
					dst->val.btval = 
#line 221 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	/* when converting from oid, there's no need to compare to GDK_bte_min,
	 * since source value is unsigned (i.e. >= 0) and all GDK_*_min values
	 * are <= 0 (in fact, compilers may warn about the test) */
	((lng) src->val.oval > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.oval


#line 446 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_wrd:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.wval < (lng) GDK_bte_min || (lng) src->val.wval > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.wval


#line 449 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_lng:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.lval < (lng) GDK_bte_min || (lng) src->val.lval > (lng) GDK_bte_max) ? bte_nil : (bte) src->val.lval


#line 452 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_flt:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((dbl) src->val.fval < (dbl) GDK_bte_min || (dbl) src->val.fval > (dbl) GDK_bte_max) ? bte_nil : (bte) src->val.fval


#line 455 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_dbl:
					dst->val.btval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((dbl) src->val.dval < (dbl) GDK_bte_min || (dbl) src->val.dval > (dbl) GDK_bte_max) ? bte_nil : (bte) src->val.dval


#line 458 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				}
				break;
			case TYPE_sht:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.shval = (sht) src->val.cval[0];
					break;
				case TYPE_bte:
					dst->val.shval = (sht) src->val.btval;
					break;
				case TYPE_sht:
					dst->val.shval = (sht) src->val.shval;
					break;
				case TYPE_int:
					dst->val.shval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.ival < (lng) GDK_sht_min || (lng) src->val.ival > (lng) GDK_sht_max) ? sht_nil : (sht) src->val.ival


#line 475 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
;
					break;
				case TYPE_bat:
					dst->val.shval = 
#line 219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_value.mx"
	((lng) src->val.bval < (lng) GDK_sht_min || (lng) src->val.bval > (lng) GDK_sht_max) ? sht_nil : (sht) src->val.bval


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