static int DaoValue_MoveVariant( DaoValue *src, DaoValue **dest, DaoType *tp )
{
DaoType *itp = NULL;
daoint j, k, n, mt = 0;
for(j=0,n=tp->nested->size; j<n; j++){
k = DaoType_MatchValue( tp->nested->items.pType[j], src, NULL );
if( k > mt ){
itp = tp->nested->items.pType[j];
mt = k;
if( mt == DAO_MT_EQ ) break;
}
}
if( itp == NULL ) return 0;
return DaoValue_Move( src, dest, itp );
}
static int DaoValue_TryCastTuple( DaoValue *src, DaoValue **dest, DaoType *tp )
{
DaoTuple *tuple;
DaoType **item_types = tp->args->items.pType;
DaoType *totype = src->xTuple.ctype;
DaoValue **data = src->xTuple.values;
DMap *names = totype ? totype->mapNames : NULL;
DNode *node, *search;
daoint i, T = tp->args->size;
int tm, eqs = 0;
/*
// Auto-cast tuple type, on the following conditions:
// (1) the item values of "dest" must match exactly to the item types of "tp";
// (2) "tp->mapNames" must contain "(*dest)->xTuple.ctype->mapNames";
*/
if( src->xTuple.ctype == NULL ){
GC_IncRC( tp );
src->xTuple.ctype = tp;
return 1;
}
if( DaoType_MatchValue( tp, src, NULL ) < DAO_MT_SIM ) return 1; /* Redundant? */
/*
// Casting is not necessary if the tuple's field names are a superset of the
// field names of the target type:
*/
if( tp->mapNames == NULL || tp->mapNames->size ==0 ) goto Finalize;
if( names ){
daoint count = 0;
for(node=DMap_First(names); node; node=DMap_Next(names,node)){
search = DMap_Find( tp->mapNames, node->key.pVoid );
if( search && node->value.pInt != search->value.pInt ) return 0;
count += search != NULL;
}
/* be superset of the field names of the target type: */
if( count == tp->mapNames->size ) goto Finalize;
}
Finalize:
tuple = DaoTuple_New( T );
for(i=0; i<T; i++){
DaoType *it = item_types[i];
if( it->tid == DAO_PAR_NAMED ) it = & it->aux->xType;
DaoValue_Move( data[i], tuple->values+i, it );
}
GC_IncRC( tp );
tuple->ctype = tp;
GC_Assign( dest, tuple );
return 1;
}
static int DaoValue_MoveVariant( DaoValue *src, DaoValue **dest, DaoType *tp, DaoType *C )
{
DaoType *itp = NULL;
int n = tp->args->size;
int j, k, mt;
for(j=0,mt=0; j<n; j++){
DaoType *itp2 = tp->args->items.pType[j];
if( tp->invar ) itp2 = DaoType_GetInvarType( itp2 );
k = DaoType_MatchValue( itp2, src, NULL );
if( k > mt ){
itp = itp2;
mt = k;
if( mt >= DAO_MT_EQ ) break;
}
}
if( itp == NULL ) return 0;
return DaoValue_Move5( src, dest, itp, C, NULL );
}
int DaoValue_Move4( DaoValue *S, DaoValue **D, DaoType *T, DMap *defs, DaoDataCache *cache )
{
int tm = 1;
switch( (T->tid << 8) | S->type ){
case (DAO_INTEGER << 8) | DAO_INTEGER :
case (DAO_INTEGER << 8) | DAO_FLOAT :
case (DAO_INTEGER << 8) | DAO_DOUBLE :
case (DAO_FLOAT << 8) | DAO_INTEGER :
case (DAO_FLOAT << 8) | DAO_FLOAT :
case (DAO_FLOAT << 8) | DAO_DOUBLE :
case (DAO_DOUBLE << 8) | DAO_INTEGER :
case (DAO_DOUBLE << 8) | DAO_FLOAT :
case (DAO_DOUBLE << 8) | DAO_DOUBLE :
case (DAO_COMPLEX << 8) | DAO_COMPLEX :
case (DAO_LONG << 8) | DAO_LONG :
case (DAO_STRING << 8) | DAO_STRING :
S = DaoValue_SimpleCopyWithTypeX( S, T, cache );
GC_ShiftRC( S, *D );
*D = S;
return 1;
}
if( !(S->xTuple.trait & DAO_VALUE_CONST) ){
DaoType *ST = NULL;
switch( (S->type << 8) | T->tid ){
case (DAO_TUPLE<<8)|DAO_TUPLE : ST = S->xTuple.unitype; break;
case (DAO_ARRAY<<8)|DAO_ARRAY : ST = dao_array_types[ S->xArray.etype ]; break;
case (DAO_LIST <<8)|DAO_LIST : ST = S->xList.unitype; break;
case (DAO_MAP <<8)|DAO_MAP : ST = S->xMap.unitype; break;
case (DAO_CDATA<<8)|DAO_CDATA : ST = S->xCdata.ctype; break;
case (DAO_CSTRUCT<<8)|DAO_CSTRUCT : ST = S->xCstruct.ctype; break;
case (DAO_OBJECT<<8)|DAO_OBJECT : ST = S->xObject.defClass->objType; break;
}
if( ST == T ){
DaoValue *D2 = *D;
GC_ShiftRC( S, D2 );
*D = S;
return 1;
}
}
if( (T->tid == DAO_OBJECT || T->tid == DAO_CDATA || T->tid == DAO_CSTRUCT) && S->type == DAO_OBJECT ){
if( S->xObject.defClass != & T->aux->xClass ){
S = DaoObject_CastToBase( S->xObject.rootObject, T );
tm = (S != NULL);
}
}else if( (T->tid == DAO_CLASS || T->tid == DAO_CTYPE) && S->type == DAO_CLASS ){
if( S->xClass.clsType != T && T->aux != NULL ){ /* T->aux == NULL for "class"; */
S = DaoClass_CastToBase( (DaoClass*)S, T );
tm = (S != NULL);
}
}else if( T->tid == DAO_CTYPE && S->type == DAO_CTYPE ){
if( S->xCtype.ctype != T ){
S = DaoType_CastToParent( S, T );
tm = (S != NULL);
}
}else if( T->tid == DAO_ROUTINE && T->overloads == 0 && S->type == DAO_ROUTINE && S->xRoutine.overloads ){
DArray *routines = S->xRoutine.overloads->routines;
int i, k, n;
/*
// Do not use DaoRoutine_ResolveByType( S, ... )
// "S" should match to "T", not the other way around!
*/
tm = 0;
for(i=0,n=routines->size; i<n; i++){
DaoRoutine *rout = routines->items.pRoutine[i];
k = rout->routType == T ? DAO_MT_EQ : DaoType_MatchTo( rout->routType, T, defs );
if( k > tm ) tm = k;
if( rout->routType == T ){
S = (DaoValue*) rout;
break;
}
}
}else{
tm = DaoType_MatchValue( T, S, defs );
}
#if 0
if( tm ==0 ){
printf( "T = %p; S = %p, type = %i %i\n", T, S, S->type, DAO_ROUTINE );
printf( "T: %s %i %i\n", T->name->mbs, T->tid, tm );
if( S->type == DAO_LIST ) printf( "%s\n", S->xList.unitype->name->mbs );
if( S->type == DAO_TUPLE ) printf( "%p\n", S->xTuple.unitype );
}
printf( "S->type = %p %s %i\n", S, T->name->mbs, tm );
#endif
if( tm == 0 ) return 0;
/* composite known types must match exactly. example,
* where it will not work if composite types are allowed to match loosely.
* d : list<list<int>> = {};
* e : list<float> = { 1.0 };
* d.append( e );
*
* but if d is of type list<list<any>>,
* the matching do not necessary to be exact.
*/
S = DaoValue_SimpleCopyWithTypeX( S, T, cache );
GC_ShiftRC( S, *D );
*D = S;
if( S->type == DAO_TUPLE && S->xTuple.unitype != T && tm >= DAO_MT_SIM ){
return DaoValue_TryCastTuple( S, D, T );
}else if( T && T->tid == S->type && !(T->attrib & DAO_TYPE_SPEC) ){
DaoValue_SetType( S, T );
}
return 1;
}
DaoValue* DaoValue_Convert( DaoValue *self, DaoType *type, int copy, DaoProcess *proc )
{
DaoTypeCore *core = DaoValue_GetTypeCore( self );
DaoValue *value = self;
DaoType *at;
if( type->tid & DAO_ANY ){
if( copy == 0 ) return value;
at = DaoValue_GetType( value, proc->vmSpace );
at = DaoType_GetBaseType( at );
if( at == NULL ) return NULL;
if( DaoType_IsImmutable( at ) ) return value;
if( value->type >= DAO_ARRAY && value->type <= DAO_TUPLE ){
at = DaoNamespace_MakeInvarSliceType( proc->activeNamespace, at );
return DaoValue_CopyContainer( value, at );
}else if( core != NULL && core->Copy != NULL ){
return core->Copy( value, NULL );
}
return NULL;
}else if( type->tid == DAO_CINVALUE ){
DaoCinType *cintype = (DaoCinType*) type->aux;
if( value->type == DAO_CINVALUE && value->xCinValue.cintype == cintype ) return value;
if( value->type == DAO_CINVALUE && DaoType_MatchValue( type, value, NULL ) ) return value;
at = DaoNamespace_GetType( proc->activeNamespace, value );
if( cintype->target == at || DaoType_MatchTo( cintype->target, at, NULL ) >= DAO_MT_CIV ){
proc->cinvalue.cintype = cintype;
proc->cinvalue.value = value;
return (DaoValue*) & proc->cinvalue;
}
return NULL;
}else if( type->tid == DAO_INTERFACE ){
DaoInterface *inter = (DaoInterface*) type->aux;
DaoRoutine *incompatible;
if( type->aux == NULL ){ /* type "interface": */
if( value->type != DAO_INTERFACE ) return NULL;
return value;
}
if( value->type == DAO_CINVALUE && DaoType_MatchValue( type, value, NULL ) ) return value;
at = DaoNamespace_GetType( proc->activeNamespace, value );
if( inter->concretes ){
DaoCinType *cintype = DaoInterface_GetConcrete( inter, at );
if( cintype ){
proc->cinvalue.cintype = cintype;
proc->cinvalue.value = value;
return (DaoValue*) & proc->cinvalue;
}
}
switch( value->type ){
case DAO_OBJECT :
value = (DaoValue*) value->xObject.rootObject;
at = value->xObject.defClass->objType;
break;
case DAO_CSTRUCT :
case DAO_CDATA :
if( value->xCstruct.object ){
value = (DaoValue*) value->xCstruct.object->rootObject;
at = value->xObject.defClass->objType;
}
break;
}
/* Automatic binding when casted to an interface: */
incompatible = DaoInterface_BindTo( inter, at, NULL );
if( incompatible != NULL ){
DString *buffer = DString_New();
DString_AppendChars( buffer, "Interface method " );
DString_Append( buffer, inter->abtype->name );
DString_AppendChars( buffer, "::" );
DString_Append( buffer, incompatible->routName );
DString_AppendChars( buffer, "() is not available in the source type;" );
DaoProcess_DeferException( proc, "Error::Type", buffer->chars );
DString_Delete( buffer );
return NULL;
}
return value;
}else if( type->tid == DAO_VARIANT ){
DaoType *best = NULL;
int i, n, max = DAO_MT_NOT;
for(i=0,n=type->args->size; i<n; i++){
DaoType *itype = type->args->items.pType[i];
int mt = DaoType_MatchValue( itype, self, NULL );
if( mt > max ){
best = itype;
max = mt;
}
}
if( best == NULL ) return NULL;
return DaoValue_Convert( self, best, copy, proc );
}
if( core == NULL || core->DoConversion == NULL ) return NULL;
value = core->DoConversion( self, type, copy, proc );
if( value == NULL || value->type <= DAO_ENUM || copy == 0 ) return value;
if( value == self /*|| DaoValue_ChildOf( value, self ) || DaoValue_ChildOf( self, value )*/ ){
// No way to determine inheritance relationship between wrapped C++ objects;
if( value->type >= DAO_ARRAY && value->type <= DAO_TUPLE ){
DaoType *type = DaoValue_GetType( value, proc->vmSpace );
if( type == NULL ) return NULL;
type = DaoNamespace_MakeInvarSliceType( proc->activeNamespace, type );
return DaoValue_CopyContainer( value, type );
}
if( core == NULL || core->Copy == NULL ) return NULL;
value = core->Copy( value, NULL ); /* Copy invariable value; */
if( value == NULL ) return NULL;
DaoProcess_CacheValue( proc, value );
}
return value;
}
int DaoValue_Move4( DaoValue *S, DaoValue **D, DaoType *T, DaoType *C, DMap *defs )
{
DaoCinType *cintype;
int tm = 1;
switch( (T->tid << 8) | S->type ){
case (DAO_BOOLEAN << 8) | DAO_BOOLEAN :
case (DAO_BOOLEAN << 8) | DAO_INTEGER :
case (DAO_BOOLEAN << 8) | DAO_FLOAT :
case (DAO_INTEGER << 8) | DAO_BOOLEAN :
case (DAO_INTEGER << 8) | DAO_INTEGER :
case (DAO_INTEGER << 8) | DAO_FLOAT :
case (DAO_FLOAT << 8) | DAO_BOOLEAN :
case (DAO_FLOAT << 8) | DAO_INTEGER :
case (DAO_FLOAT << 8) | DAO_FLOAT :
case (DAO_COMPLEX << 8) | DAO_COMPLEX :
case (DAO_STRING << 8) | DAO_STRING :
case (DAO_CINVALUE<< 8) | DAO_CINVALUE :
S = DaoValue_SimpleCopyWithTypeX( S, T, C );
GC_Assign( D, S );
return 1;
}
switch( S->type ){
case DAO_ENUM : if( S->xEnum.subtype == DAO_ENUM_SYM && T->realnum ) return 0; break;
case DAO_OBJECT : if( S->xObject.isNull ) return 0; break;
case DAO_CDATA : if( S->xCdata.data == NULL && ! DaoType_IsNullable(T) ) return 0; break;
}
if( !(S->xBase.trait & DAO_VALUE_CONST) ){
DaoVmSpace *vms;
DaoType *ST = NULL;
switch( (S->type << 8) | T->tid ){
case (DAO_ARRAY<<8)|DAO_ARRAY :
vms = DaoType_GetVmSpace( T );
ST = vms->typeArrays[ S->xArray.etype ]; break;
case (DAO_TUPLE<<8)|DAO_TUPLE : ST = S->xTuple.ctype; break;
case (DAO_LIST <<8)|DAO_LIST : ST = S->xList.ctype; break;
case (DAO_MAP <<8)|DAO_MAP : ST = S->xMap.ctype; break;
case (DAO_CDATA<<8)|DAO_CDATA : ST = S->xCdata.ctype; break;
case (DAO_CSTRUCT<<8)|DAO_CSTRUCT : ST = S->xCstruct.ctype; break;
case (DAO_OBJECT<<8)|DAO_OBJECT : ST = S->xObject.defClass->objType; break;
}
if( ST == T ){
if( ST->tid == DAO_CSTRUCT || ST->tid == DAO_CDATA ){
DaoValue_MoveCstruct( S, D, C != NULL && C->invar != 0 );
}else{
GC_Assign( D, S );
}
return 1;
}
}
if( (T->tid == DAO_OBJECT || T->tid == DAO_CSTRUCT || T->tid == DAO_CDATA) && S->type == DAO_OBJECT ){
if( S->xObject.defClass != & T->aux->xClass ){
S = DaoObject_CastToBase( S->xObject.rootObject, T );
if( S != NULL && S->type == DAO_CDATA && S->xCdata.data == NULL ){
if( ! DaoType_IsNullable( T ) ) return 0;
}
tm = (S != NULL);
}
}else if( (T->tid == DAO_CLASS || T->tid == DAO_CTYPE) && S->type == DAO_CLASS ){
if( S->xClass.clsType != T && T->aux != NULL ){ /* T->aux == NULL for "class"; */
S = DaoClass_CastToBase( (DaoClass*)S, T );
tm = (S != NULL);
}
}else if( T->tid == DAO_CTYPE && S->type == DAO_CTYPE ){
if( S->xCtype.classType != T ){
S = DaoType_CastToParent( S, T );
tm = (S != NULL);
}
}else if( T->tid == DAO_ROUTINE && T->subtid != DAO_ROUTINES && S->type == DAO_ROUTINE && S->xRoutine.overloads ){
DList *routines = S->xRoutine.overloads->routines;
int i, k, n;
/*
// Do not use DaoRoutine_ResolveByType( S, ... )
// "S" should match to "T", not the other way around!
*/
tm = 0;
for(i=0,n=routines->size; i<n; i++){
DaoRoutine *rout = routines->items.pRoutine[i];
k = rout->routType == T ? DAO_MT_EQ : DaoType_MatchTo( rout->routType, T, defs );
if( k > tm ) tm = k;
if( rout->routType == T ){
S = (DaoValue*) rout;
break;
}
}
}else{
tm = DaoType_MatchValue( T, S, defs );
}
#if 0
if( tm ==0 ){
printf( "T = %p; S = %p, type = %i %i\n", T, S, S->type, DAO_ROUTINE );
printf( "T: %s %i %i\n", T->name->chars, T->tid, tm );
if( S->type == DAO_LIST ) printf( "%s\n", S->xList.ctype->name->chars );
if( S->type == DAO_TUPLE ) printf( "%p\n", S->xTuple.ctype );
}
printf( "S->type = %p %s %i\n", S, T->name->chars, tm );
#endif
if( tm == 0 ) return 0;
/*
// Composite types must match exactly. Example,
// where it will not work if composite types are allowed to match loosely.
// d : list<list<int>> = {};
// e : list<float> = { 1.0 };
// d.append( e );
//
// But if d is of type list<list<any>>,
// the matching do not necessary to be exact.
*/
cintype = NULL;
if( T->tid == DAO_CINVALUE ){
if( DaoType_MatchValue( T->aux->xCinType.target, S, NULL ) >= DAO_MT_CIV ){
cintype = (DaoCinType*) T->aux;
}
}else if( T->tid == DAO_INTERFACE && T->aux->xInterface.concretes ){
DaoInterface *inter = (DaoInterface*) T->aux;
DaoType *st = DaoValue_GetType( S, inter->nameSpace->vmSpace );
DNode *it;
cintype = DaoInterface_GetConcrete( inter, st );
if( cintype == NULL ){
for(it=DMap_First(inter->concretes); it; it=DMap_Next(inter->concretes,it)){
if( DaoType_MatchValue( it->key.pType, S, NULL ) >= DAO_MT_CIV ){
cintype = (DaoCinType*) it->value.pVoid;
break;
}
}
}
}
if( cintype ){
S = (DaoValue*) DaoCinValue_New( cintype, S );
}else if( S->type == DAO_CSTRUCT || S->type == DAO_CDATA ){
DaoValue_MoveCstruct( S, D, C != NULL && C->invar != 0 );
return 1;
}else{
S = DaoValue_SimpleCopyWithTypeX( S, T, C );
}
GC_Assign( D, S );
if( S->type == DAO_TUPLE && S->xTuple.ctype != T && tm == DAO_MT_SIM ){
return DaoValue_TryCastTuple( S, D, T );
}else if( T && T->tid == S->type && !(T->attrib & DAO_TYPE_SPEC) ){
DaoValue_SetType( S, T );
}
return 1;
}
