gdk_value.mx

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

				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] = @:valcheck(src->val.shval,chr,lng)@;
					break;
				case TYPE_int:
					dst->val.cval[0] = @:valcheck(src->val.ival,chr,lng)@;
					break;
				case TYPE_bat:
					dst->val.cval[0] = @:valcheck(src->val.bval,chr,lng)@;
					break;
				case TYPE_oid:
					dst->val.cval[0] = @:valcheck_r(src->val.oval,chr,lng)@;
					break;
				case TYPE_wrd:
					dst->val.cval[0] = @:valcheck(src->val.wval,chr,lng)@;
					break;
				case TYPE_lng:
					dst->val.cval[0] = @:valcheck(src->val.lval,chr,lng)@;
					break;
				case TYPE_flt:
					dst->val.cval[0] = @:valcheck(src->val.fval,chr,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.cval[0] = @:valcheck(src->val.dval,chr,dbl)@;
					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 = @:valcheck(src->val.shval,bte,lng)@;
					break;
				case TYPE_int:
					dst->val.btval = @:valcheck(src->val.ival,bte,lng)@;
					break;
				case TYPE_bat:
					dst->val.btval = @:valcheck(src->val.bval,bte,lng)@;
					break;
				case TYPE_oid:
					dst->val.btval = @:valcheck_r(src->val.oval,bte,lng)@;
					break;
				case TYPE_wrd:
					dst->val.btval = @:valcheck(src->val.wval,bte,lng)@;
					break;
				case TYPE_lng:
					dst->val.btval = @:valcheck(src->val.lval,bte,lng)@;
					break;
				case TYPE_flt:
					dst->val.btval = @:valcheck(src->val.fval,bte,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.btval = @:valcheck(src->val.dval,bte,dbl)@;
					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 = @:valcheck(src->val.ival,sht,lng)@;
					break;
				case TYPE_bat:
					dst->val.shval = @:valcheck(src->val.bval,sht,lng)@;
					break;
				case TYPE_oid:
					dst->val.shval = @:valcheck_r(src->val.oval,sht,lng)@;
					break;
				case TYPE_wrd:
					dst->val.shval = @:valcheck(src->val.wval,sht,lng)@;
					break;
				case TYPE_lng:
					dst->val.shval = @:valcheck(src->val.lval,sht,lng)@;
					break;
				case TYPE_flt:
					dst->val.shval = @:valcheck(src->val.fval,sht,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.shval = @:valcheck(src->val.dval,sht,dbl)@;
					break;
				}
				break;
			case TYPE_int:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.ival = (int) src->val.cval[0];
					break;
				case TYPE_bte:
					dst->val.ival = (int) src->val.btval;
					break;
				case TYPE_sht:
					dst->val.ival = (int) src->val.shval;
					break;
				case TYPE_int:
					dst->val.ival = (int) src->val.ival;
					break;
				case TYPE_bat:
					dst->val.ival = (int) src->val.bval;
					break;
				case TYPE_oid:
					dst->val.ival = @:valcheck_r(src->val.oval,int,lng)@;
					break;
				case TYPE_wrd:
#if SIZEOF_WRD == SIZEOF_INT
					dst->val.ival = (int) src->val.wval;
#else
					dst->val.ival = @:valcheck(src->val.wval,int,lng)@;
#endif
					break;
				case TYPE_lng:
					dst->val.ival = @:valcheck(src->val.lval,int,lng)@;
					break;
				case TYPE_flt:
					dst->val.ival = @:valcheck(src->val.fval,int,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.ival = @:valcheck(src->val.dval,int,dbl)@;
					break;
				}
				break;
			case TYPE_oid:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.oval = @:valcheck_l(src->val.cval[0],oid,lng)@;
					break;
				case TYPE_bte:
					dst->val.oval = @:valcheck_l(src->val.btval,oid,lng)@;
					break;
				case TYPE_sht:
					dst->val.oval = @:valcheck_l(src->val.shval,oid,lng)@;
					break;
				case TYPE_int:
					dst->val.oval = @:valcheck_l(src->val.ival,oid,lng)@;
					break;
				case TYPE_bat:
					dst->val.oval = @:valcheck_l(src->val.bval,oid,lng)@;
					break;
				case TYPE_oid:
					dst->val.oval = (oid) src->val.oval;
					break;
				case TYPE_wrd:
#if SIZEOF_WRD == SIZEOF_OID
					dst->val.oval = @:valcheck_l(src->val.wval,oid,lng)@;
#else
					dst->val.oval = @:valcheck(src->val.wval,oid,lng)@;
#endif
					break;
				case TYPE_lng:
					dst->val.oval = @:valcheck(src->val.lval,oid,lng)@;
					break;
				case TYPE_flt:
					dst->val.oval = @:valcheck(src->val.fval,oid,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.oval = @:valcheck(src->val.dval,oid,dbl)@;
					break;
				}
				break;
			case TYPE_wrd:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.wval = (wrd) src->val.cval[0];
					break;
				case TYPE_bte:
					dst->val.wval = (wrd) src->val.btval;
					break;
				case TYPE_sht:
					dst->val.wval = (wrd) src->val.shval;
					break;
				case TYPE_int:
					dst->val.wval = (wrd) src->val.ival;
					break;
				case TYPE_bat:
					dst->val.wval = (wrd) src->val.bval;
					break;
				case TYPE_oid:
					dst->val.wval = (wrd) src->val.oval;
					break;
				case TYPE_wrd:
					dst->val.wval = (wrd) src->val.wval;
					break;
				case TYPE_lng:
#if SIZEOF_LNG == SIZEOF_WRD
					dst->val.wval = (wrd) src->val.lval;
#else
					dst->val.wval = @:valcheck(src->val.lval,wrd,lng)@;
#endif
					break;
				case TYPE_flt:
					dst->val.wval = @:valcheck(src->val.fval,wrd,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.wval = @:valcheck(src->val.dval,wrd,dbl)@;
					break;
				}
				break;
			case TYPE_lng:
				switch (src_tpe) {
				case TYPE_bit:
				case TYPE_chr:
					dst->val.lval = (lng) src->val.cval[0];
					break;
				case TYPE_sht:
					dst->val.lval = (lng) src->val.shval;
					break;
				case TYPE_bte:
					dst->val.lval = (lng) src->val.btval;
					break;
				case TYPE_int:
					dst->val.lval = (lng) src->val.ival;
					break;
				case TYPE_bat:
					dst->val.lval = (lng) src->val.bval;
					break;
				case TYPE_oid:
					dst->val.lval = (lng) src->val.oval;
					break;
				case TYPE_wrd:
					dst->val.lval = (lng) src->val.wval;
					break;
				case TYPE_lng:
					dst->val.lval = (lng) src->val.lval;
					break;
				case TYPE_flt:
					dst->val.lval = @:valcheck(src->val.fval,lng,dbl)@;
					break;
				case TYPE_dbl:
					dst->val.lval = @:valcheck(src->val.dval,lng,dbl)@;
					break;
				}
				break;
			case TYPE_flt:
				@:valfconvert(dst->val.fval,flt)@;
				break;
			case TYPE_dbl:
				@:valfconvert(dst->val.dval,dbl)@;
				break;
			}
		}
	}
	return p;
}

/* VALconvert1, but returns a BAT* instead of a bat* and (thus) adds a physical fix to the bat */
ptr
VALconvert2(int typ, ValPtr src, ValPtr dst)
{
	ptr p = VALconvert1(typ, src, dst);
	if (typ == TYPE_bat && p != ILLEGALVALUE) {
		p = BATdescriptor(dst->val.bval); /* fixes the bat */
		if (p == NULL) p = ILLEGALVALUE;
	}
	return p;
}

ptr
VALconvert(int typ, ValPtr t)
{
	int src_tpe = t->vtype, dst_tpe = typ;
	ptr p;
	ValRecord dst;

	/* 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);

	/* first convert into a new location */
	p = VALconvert1(typ, t, &dst);
	/* then maybe free the old */
	if (src_tpe != dst_tpe && t->vtype != typ && dst_tpe != TYPE_void &&
	    (src_tpe >= TYPE_str || dst_tpe >= TYPE_str))
		VALclear(t);
	/* and finally copy the result */
	*t = dst;
	/* make sure we return the correct type (not the storage type) */
	t->vtype = typ;
	return p == ILLEGALVALUE ? p : 	VALptr(t);
}

@}
@