void DaoxProfiler_Delete( DaoxProfiler *self )
{
DMutex_Destroy( & self->mutex );
DMap_Delete( self->profile );
DMap_Delete( self->one );
dao_free( self );
}
/*
// Note: reference count is not handled for "self"!
// But it is cached in the DaoProcess object, so no need to handle it by user!
*/
int DaoValue_Deserialize( DaoValue **self, DString *serial, DaoNamespace *ns, DaoProcess *proc )
{
DaoParser *parser = DaoParser_New();
DArray *types = DArray_New(0);
DMap *omap = DMap_New(0,0);
int rc;
*self = NULL;
parser->nameSpace = ns;
parser->vmSpace = ns->vmSpace;
DaoParser_LexCode( parser, DString_GetMBS( serial ), 0 );
if( parser->tokens->size == 0 ) goto Failed;
DArray_PushFront( types, NULL );
rc = DaoParser_Deserialize( parser, 0, parser->tokens->size-1, self, types, ns, proc, omap );
if( *self ) DaoProcess_CacheValue( proc, *self );
DaoParser_Delete( parser );
DArray_Delete( types );
DMap_Delete( omap );
return rc;
Failed:
DaoParser_Delete( parser );
DArray_Delete( types );
DMap_Delete( omap );
return 0;
}
static void DaoCallServer_Delete( DaoCallServer *self )
{
daoint i;
for(i=0; i<self->threads->size; i++){
DaoCallThread_Delete( (DaoCallThread*)self->threads->items.pVoid[i] );
}
for(i=0; i<self->caches->size; ++i){
DaoTaskEvent_Delete( (DaoTaskEvent*) self->caches->items.pVoid[i] );
}
DList_Delete( self->threads );
DList_Delete( self->functions );
DList_Delete( self->parameters );
DList_Delete( self->owners );
DList_Delete( self->events );
DList_Delete( self->events2 );
DList_Delete( self->caches );
DMap_Delete( self->waitings );
DMap_Delete( self->pending );
DMap_Delete( self->active );
DMutex_Destroy( & self->mutex );
DCondVar_Destroy( & self->condv );
DCondVar_Destroy( & self->condv2 );
DThread_Destroy( & self->timer );
dao_free( self );
}
void DaoInterface_Delete( DaoInterface *self )
{
#ifdef DAO_USE_GC_LOGGER
DaoObjectLogger_LogDelete( (DaoValue*) self );
#endif
if( self->concretes ) DMap_Delete( self->concretes );
GC_DecRC( self->abtype );
DList_Delete( self->supers );
DMap_Delete( self->methods );
dao_free( self );
}
static void DaoIO_Writeln0( DaoStream *self, DaoProcess *proc, DaoValue *p[], int N )
{
DaoValue *params[DAO_MAX_PARAM];
DMap *cycmap = NULL;
int i;
if( DaoIO_CheckMode( self, proc, DAO_STREAM_WRITABLE ) == 0 ) return;
for(i=0; i<N; i++){
if( p[i]->type > DAO_ARRAY ){
cycmap = DHash_New(0,0);
break;
}
}
/*
// DaoValue_Print() may call user defined function and change the stack
// and invalidate the parameter array:
*/
memmove( params, p, N*sizeof(DaoValue*) );
for(i=0; i<N; i++){
if( params[i]->type > DAO_ARRAY ) DMap_Reset( cycmap );
DaoValue_Print( params[i], self, cycmap, proc );
if( i+1<N ) DaoStream_WriteChars( self, " ");
}
DaoStream_WriteChars( self, "\n");
if( cycmap ) DMap_Delete( cycmap );
}
void DaoxFont_Delete( DaoxFont *self )
{
DMap_Delete( self->glyphs );
DString_Delete( self->buffer );
DaoCstruct_Free( (DaoCstruct*) self );
dao_free( self );
}
int DaoCass_DeriveMixinData( DaoClass *self )
{
DMap *mixed = DMap_New(0,D_MAP);
DaoMethodFields *mf = DaoMethodFields_New();
DNode *it, *search;
daoint i, bl = 1;
self->cstMixinStart = self->constants->size;
self->glbMixinStart = self->variables->size;
self->objMixinStart = self->instvars->size;
for(i=0; i<self->mixinBases->size; ++i){
DaoClass *mixin = self->mixinBases->items.pClass[i];
bl &= DaoClass_MixIn( self, mixin, mixed, mf );
}
self->cstMixinEnd = self->constants->size;
self->glbMixinEnd = self->variables->size;
self->objMixinEnd = self->instvars->size;
DaoClass_SetupMethodFields( self, mf );
self->cstMixinEnd2 = self->constants->size;
self->glbMixinEnd2 = self->variables->size;
self->objMixinEnd2 = self->instvars->size;
DMap_Delete( mixed );
DaoMethodFields_Delete( mf );
return bl;
}
static void DMap_SortMethods( DMap *hash, DList *methods )
{
DMap *map = DMap_New( DAO_DATA_STRING, 0 );
DString *name = DString_New();
DNode *it;
daoint i, n;
for(it=DMap_First(hash); it; it=DMap_Next(hash,it)){
if( it->value.pRoutine->overloads ){
DRoutines *one = it->value.pRoutine->overloads;
for(i=0,n=one->routines->size; i<n; i++){
DaoRoutine *rout = one->routines->items.pRoutine[i];
DString_Assign( name, rout->routName );
DString_AppendChars( name, " " );
DString_Append( name, rout->routType->name );
DMap_Insert( map, name, (void*)rout );
}
}else{
DaoRoutine *rout = it->value.pRoutine;
DString_Assign( name, rout->routName );
DString_AppendChars( name, " " );
DString_Append( name, rout->routType->name );
DMap_Insert( map, name, (void*)rout );
}
}
DList_Clear( methods );
for(it=DMap_First(map); it; it=DMap_Next(map,it))
DList_Append( methods, it->value.pVoid );
DMap_Delete( map );
DString_Delete( name );
}
int DaoInterface_BindTo( DaoInterface *self, DaoType *type, DMap *binds )
{
DNode *it;
DMap *newbinds = NULL;
DList *methods;
void *pvoid[2];
daoint i, n, bl;
/* XXX locking */
if( type->interfaces == NULL ) type->interfaces = DHash_New( DAO_DATA_VALUE, 0 );
pvoid[0] = type;
pvoid[1] = self->abtype;
if( (it = DMap_Find( type->interfaces, self )) ) return it->value.pVoid != NULL;
if( binds && DMap_Find( binds, pvoid ) ) return 1;
if( binds ==NULL ) newbinds = binds = DHash_New( DAO_DATA_VOID2, 0 );
DaoInterface_TempBind( self, type, binds );
methods = DList_New(0);
DMap_SortMethods( self->methods, methods );
bl = DaoInterface_CheckBind( methods, type, binds );
DList_Delete( methods );
if( newbinds ) DMap_Delete( newbinds );
DMap_Insert( type->interfaces, self, bl ? self : NULL );
if( bl == 0 ) return 0;
for(i=0,n=self->supers->size; i<n; i++){
DaoInterface *super = (DaoInterface*) self->supers->items.pValue[i];
if( DMap_Find( type->interfaces, super ) ) continue;
DMap_Insert( type->interfaces, super, super );
}
return 1;
}
void DaoXmlParser_Delete( DaoXmlParser *self )
{
DString_Delete( self->key );
DString_Delete( self->value );
DString_Delete( self->escape );
DMap_Delete( self->escapes );
dao_free( self );
}
void DaoxResource_Delete( DaoxResource *self )
{
DaoCstruct_Free( (DaoCstruct*) self );
DMap_Delete( self->scenes );
DMap_Delete( self->lights );
DMap_Delete( self->cameras );
DMap_Delete( self->images );
DMap_Delete( self->textures );
DMap_Delete( self->effects );
DMap_Delete( self->materials );
DMap_Delete( self->geometries );
DMap_Delete( self->terrains );
dao_free( self );
}
void DaoxDataFrame_AddLabelGroup( DaoxDataFrame *self, int dim )
{
if( dim >=0 && dim < 3 ){
DMap *labmap = DHash_New(D_STRING,0);
DArray *labels = self->labels[dim];
self->groups[dim] = labels->size;
DArray_Append( labels, labmap );
DMap_Delete( labmap );
}
}
static void DaoMT_RoutMutexSet( DMap *mutexes )
{
DNode *it;
for(it=DMap_First(mutexes); it; it=DMap_Next(mutexes,it)){
DMutex *mutex = (DMutex*) it->value.pVoid;
DMutex_Destroy( mutex );
dao_free( mutex );
}
DMap_Delete( mutexes );
}
void DaoClass_MakeInterface( DaoClass *self )
{
daoint i, j;
DaoType *tp;
DaoRoutine *meth;
DaoInterface *inter = self->inter;
DMap *deftypes = DHash_New(0,0);
DArray_Clear( self->inter->supers );
DMap_Clear( self->inter->methods );
if( self->parent && self->parent->type == DAO_CLASS )
DArray_Append( inter->supers, self->parent->xClass.inter );
for(i=0; i<self->cstDataName->size; ++i){
DString *name = self->cstDataName->items.pString[i];
DaoValue *value = self->constants->items.pConst[i]->value;
DaoRoutine *rout = (DaoRoutine*) value;
DNode *it;
if( value->type != DAO_ROUTINE ) continue;
if( value->xRoutine.attribs & DAO_ROUT_DECORATOR ) continue;
it = MAP_Find( self->lookupTable, rout->routName );
if( it == NULL || LOOKUP_PM( it->value.pInt ) != DAO_DATA_PUBLIC ) continue;
DMap_Reset( deftypes );
DMap_Insert( deftypes, rout->routHost, inter->abtype );
if( rout->overloads == NULL ){
tp = DaoType_DefineTypes( rout->routType, rout->nameSpace, deftypes );
if( tp == NULL ) continue; /* TODO: handle error; */
meth = DaoRoutine_New( rout->nameSpace, inter->abtype, 0 );
meth->attribs = rout->attribs;
DString_Assign( meth->routName, rout->routName );
GC_ShiftRC( tp, meth->routType );
meth->routType = tp;
DaoMethods_Insert( inter->methods, meth, meth->nameSpace, meth->routHost );
}else{
for(j=0; j<rout->overloads->routines->size; ++j){
DaoRoutine *rout2 = rout->overloads->routines->items.pRoutine[j];
if( rout2->attribs & DAO_ROUT_DECORATOR ) continue;
tp = DaoType_DefineTypes( rout2->routType, rout2->nameSpace, deftypes );
if( tp == NULL ) continue; /* TODO: handle error; */
meth = DaoRoutine_New( rout2->nameSpace, inter->abtype, 0 );
meth->attribs = rout2->attribs;
DString_Assign( meth->routName, rout->routName );
GC_ShiftRC( tp, meth->routType );
meth->routType = tp;
DaoMethods_Insert( inter->methods, meth, meth->nameSpace, meth->routHost );
}
}
}
DMap_Delete( deftypes );
}
int DaoValue_CompareExt( DaoValue *left, DaoValue *right, DMap *cycmap )
{
DMap *input = cycmap;
void *pters[2];
int res = 0;
if( left == right ) return 0;
if( left == NULL || right == NULL ) return left < right ? -100 : 100;
if( left->type != right->type ){
double L, R;
res = left->type < right->type ? -100 : 100;
if( left->type < DAO_BOOLEAN || left->type > DAO_FLOAT ) return res;
if( right->type < DAO_BOOLEAN || right->type > DAO_FLOAT ) return res;
L = DaoValue_GetFloat( left );
R = DaoValue_GetFloat( right );
return L == R ? 0 : (L < R ? -1 : 1);
}
switch( left->type ){
case DAO_TUPLE :
case DAO_LIST :
case DAO_OBJECT :
case DAO_CDATA :
case DAO_CSTRUCT :
pters[0] = left;
pters[1] = right;
if( cycmap != NULL ){
DNode *it = DMap_Find( cycmap, pters );
if( it != NULL ) return left < right ? -100 : 100;
}
if( cycmap == NULL ) cycmap = DHash_New(DAO_DATA_VOID2,0);
DMap_Insert( cycmap, pters, NULL );
break;
}
switch( left->type ){
case DAO_NONE : break;
case DAO_BOOLEAN : res = number_compare( left->xBoolean.value, right->xBoolean.value ); break;
case DAO_INTEGER : res = number_compare( left->xInteger.value, right->xInteger.value ); break;
case DAO_FLOAT : res = number_compare( left->xFloat.value, right->xFloat.value ); break;
case DAO_COMPLEX : res = DaoComplex_Compare( (DaoComplex*) left, (DaoComplex*) right ); break;
case DAO_STRING : res = DString_CompareUTF8( left->xString.value, right->xString.value ); break;
case DAO_ENUM : res = DaoEnum_Compare( (DaoEnum*) left, (DaoEnum*) right ); break;
case DAO_TUPLE : res = DaoTuple_Compare( (DaoTuple*) left, (DaoTuple*) right, cycmap ); break;
case DAO_LIST : res = DaoList_Compare( (DaoList*) left, (DaoList*) right, cycmap ); break;
case DAO_OBJECT : res = DaoObject_Compare( (DaoObject*)left, (DaoObject*)right, cycmap ); break;
case DAO_CDATA :
case DAO_CSTRUCT : res = DaoCstruct_Compare( (DaoCstruct*)left, (DaoCstruct*)right, cycmap ); break;
case DAO_TYPE : res = DaoType_Compare( (DaoType*) left, (DaoType*) right ); break;
#ifdef DAO_WITH_NUMARRAY
case DAO_ARRAY : res = DaoArray_Compare( (DaoArray*) left, (DaoArray*) right ); break;
#endif
default: res = left < right ? -100 : 100; break; /* Needed for map; */
}
if( cycmap != input ) DMap_Delete( cycmap );
return res;
}
void DaoValue_Print( DaoValue *self, DaoProcess *proc, DaoStream *stream, DMap *cycData )
{
DString *name;
DaoTypeBase *typer;
DMap *cd = cycData;
if( self == NULL ){
DaoStream_WriteMBS( stream, "none[0x0]" );
return;
}
if( cycData == NULL ) cycData = DMap_New(0,0);
switch( self->type ){
case DAO_INTEGER :
DaoStream_WriteInt( stream, self->xInteger.value ); break;
case DAO_FLOAT :
DaoStream_WriteFloat( stream, self->xFloat.value ); break;
case DAO_DOUBLE :
DaoStream_WriteFloat( stream, self->xDouble.value ); break;
case DAO_COMPLEX :
DaoStream_WriteFloat( stream, self->xComplex.value.real );
if( self->xComplex.value.imag >= -0.0 ) DaoStream_WriteMBS( stream, "+" );
DaoStream_WriteFloat( stream, self->xComplex.value.imag );
DaoStream_WriteMBS( stream, "C" );
break;
#ifdef DAO_WITH_LONGINT
case DAO_LONG :
name = DString_New(1);
DLong_Print( self->xLong.value, name );
DaoStream_WriteString( stream, name );
DString_Delete( name );
break;
#endif
case DAO_ENUM :
name = DString_New(1);
DaoEnum_MakeName( & self->xEnum, name );
DaoStream_WriteMBS( stream, name->mbs );
DaoStream_WriteMBS( stream, "(" );
DaoStream_WriteInt( stream, self->xEnum.value );
DaoStream_WriteMBS( stream, ")" );
DString_Delete( name );
break;
case DAO_STRING :
DaoStream_WriteString( stream, self->xString.data ); break;
default :
typer = DaoVmSpace_GetTyper( self->type );
if( typer->core->Print == DaoValue_Print ){
DaoValue_BasicPrint( self, proc, stream, cycData );
break;
}
typer->core->Print( self, proc, stream, cycData );
break;
}
if( cycData != cd ) DMap_Delete( cycData );
}
static void DaoIO_Write0( DaoStream *self, DaoProcess *proc, DaoValue *p[], int N )
{
DMap *cycData;
int i;
if( (self->attribs & (DAO_IO_FILE | DAO_IO_PIPE)) && self->file == NULL ){
DaoProcess_RaiseException( proc, DAO_ERROR, "stream is not open!" );
return;
}
cycData = DMap_New(0,0);
for(i=0; i<N; i++) DaoValue_Print( p[i], proc, self, cycData );
DMap_Delete( cycData );
}
void DaoXmlNode_Delete( DaoXmlNode *self )
{
daoint i;
for(i=0; i<self->children->size; ++i){
DaoXmlNode_Delete( (DaoXmlNode*) self->children->items.pVoid[i] );
}
DList_Delete( self->children );
DString_Delete( self->name );
DString_Delete( self->content );
DMap_Delete( self->attributes );
dao_free( self );
}
void DaoClass_Delete( DaoClass *self )
{
GC_DecRC( self->clsType );
DMap_Delete( self->abstypes );
DMap_Delete( self->lookupTable );
DMap_Delete( self->ovldRoutMap );
DArray_Delete( self->constants );
DArray_Delete( self->variables );
DArray_Delete( self->instvars );
DArray_Delete( self->objDataName );
DArray_Delete( self->cstDataName );
DArray_Delete( self->glbDataName );
DArray_Delete( self->superClass );
DArray_Delete( self->references );
if( self->vtable ) DMap_Delete( self->vtable );
if( self->protoValues ) DMap_Delete( self->protoValues );
#ifdef DAO_WITH_DYNCLASS
if( self->typeHolders ){
DArray_Delete( self->typeHolders );
DArray_Delete( self->typeDefaults );
DMap_Delete( self->instanceClasses );
}
#endif
DString_Delete( self->className );
dao_free( self );
}
static void DArray_DeleteItem( DArray *self, void *item )
{
switch( self->type ){
case DAO_DATA_VALUE : GC_DecRC( item ); break;
case DAO_DATA_VMCODE : DaoVmCodeX_Delete( (DaoVmCodeX*) item ); break;
case DAO_DATA_TOKEN : DaoToken_Delete( (DaoToken*) item ); break;
case DAO_DATA_STRING : DString_Delete( (DString*) item ); break;
case DAO_DATA_VECTOR : DVector_Delete( (DVector*) item ); break;
case DAO_DATA_ARRAY : DArray_Delete( (DArray*) item ); break;
case DAO_DATA_MAP : DMap_Delete( (DMap*) item ); break;
default : break;
}
}
void DaoCinType_Delete( DaoCinType *self )
{
#ifdef DAO_USE_GC_LOGGER
DaoObjectLogger_LogDelete( (DaoValue*) self );
#endif
GC_DecRC( self->abstract );
GC_DecRC( self->target );
GC_DecRC( self->citype );
GC_DecRC( self->vatype );
DList_Delete( self->supers );
DMap_Delete( self->methods );
dao_free( self );
}
int DaoValue_Serialize( DaoValue *self, DString *serial, DaoNamespace *ns, DaoProcess *proc )
{
DaoType *type = DaoNamespace_GetType( ns, self );
DString *buf = DString_New(1);
DMap *omap = DMap_New(0,0);
int rc;
DString_Clear( serial );
DString_ToMBS( serial );
rc = DaoValue_Serialize2( self, serial, ns, proc, type, buf, omap );
DString_Delete( buf );
DMap_Delete( omap );
return rc;
}
static void DArray_DeleteItems( DArray *self, daoint M, daoint N )
{
daoint i;
switch( self->type ){
case DAO_DATA_VALUE : for(i=M; i<N; i++) GC_DecRC( self->items.pValue[i] ); break;
case DAO_DATA_VMCODE : for(i=M; i<N; i++) DaoVmCodeX_Delete( self->items.pVmc[i] ); break;
case DAO_DATA_TOKEN : for(i=M; i<N; i++) DaoToken_Delete( self->items.pToken[i] ); break;
case DAO_DATA_STRING : for(i=M; i<N; i++) DString_Delete( self->items.pString[i] ); break;
case DAO_DATA_VECTOR : for(i=M; i<N; i++) DVector_Delete( self->items.pVector[i] ); break;
case DAO_DATA_ARRAY : for(i=M; i<N; i++) DArray_Delete( self->items.pArray[i] ); break;
case DAO_DATA_MAP : for(i=M; i<N; i++) DMap_Delete( self->items.pMap[i] ); break;
default : break;
}
}
void DaoClass_Delete( DaoClass *self )
{
GC_DecRC( self->clsType );
DMap_Delete( self->abstypes );
DMap_Delete( self->lookupTable );
DMap_Delete( self->ovldRoutMap );
DArray_Delete( self->constants );
DArray_Delete( self->variables );
DArray_Delete( self->instvars );
DArray_Delete( self->objDataName );
DArray_Delete( self->cstDataName );
DArray_Delete( self->glbDataName );
DArray_Delete( self->allBases );
DArray_Delete( self->mixinBases );
DArray_Delete( self->mixins );
DVector_Delete( self->ranges );
DVector_Delete( self->offsets );
DArray_Delete( self->references );
if( self->decoTargets ) DArray_Delete( self->decoTargets );
DString_Delete( self->className );
dao_free( self );
}
static void DaoIO_Write0( DaoStream *self, DaoProcess *proc, DaoValue *p[], int N )
{
DMap *cycmap = NULL;
int i;
for(i=0; i<N; i++){
if( p[i]->type > DAO_ARRAY ){
cycmap = DHash_New(0,0);
break;
}
}
for(i=0; i<N; i++){
if( p[i]->type > DAO_ARRAY ) DMap_Reset( cycmap );
DaoValue_Print( p[i], self, cycmap, proc );
}
if( cycmap ) DMap_Delete( cycmap );
}
void DaoObject_Print( DaoValue *self, DaoStream *stream, DMap *cycmap, DaoProcess *proc )
{
int ec = 0;
char buf[50];
DMap *inmap = cycmap;
DaoObject *object = (DaoObject*) self;
DaoValue *params[2];
DaoRoutine *meth;
sprintf( buf, "[%p]", object );
if( self == object->defClass->objType->value ){
DaoStream_WriteString( stream, object->defClass->className );
DaoStream_WriteChars( stream, "[null]" );
return;
}
if( cycmap != NULL && DMap_Find( cycmap, object ) != NULL ){
DaoStream_WriteString( stream, object->defClass->className );
DaoStream_WriteChars( stream, buf );
return;
}
if( cycmap == NULL ) cycmap = DHash_New(0,0);
DMap_Insert( cycmap, self, self );
DaoValue_Clear( & proc->stackValues[0] );
params[0] = (DaoValue*) dao_type_string;
params[1] = (DaoValue*) stream;
meth = DaoClass_FindMethod( object->defClass, "(string)", NULL );
if( meth ){
ec = DaoProcess_Call( proc, meth, self, params, 2 );
if( ec ) ec = DaoProcess_Call( proc, meth, self, params, 1 );
}else{
meth = DaoClass_FindMethod( object->defClass, "serialize", NULL );
if( meth ) ec = DaoProcess_Call( proc, meth, self, NULL, 0 );
}
if( ec ){
DaoProcess_RaiseException( proc, daoExceptionNames[ec], proc->string->chars, NULL );
}else if( meth && proc->stackValues[0] ){
DaoValue_Print( proc->stackValues[0], stream, cycmap, proc );
}else{
DaoStream_WriteString( stream, object->defClass->className );
DaoStream_WriteChars( stream, buf );
}
if( inmap == NULL ) DMap_Delete( cycmap );
}
static void DaoCinValue_Print( DaoValue *self, DaoStream *stream, DMap *cycmap, DaoProcess *proc )
{
int ec = 0;
char buf[50];
DaoRoutine *meth;
DaoValue *args[2];
DaoType *type = self->xCinValue.cintype->vatype;
DMap *inmap = cycmap;
if( cycmap != NULL && DMap_Find( cycmap, self ) != NULL ){
sprintf( buf, "[%p]", self );
DaoStream_WriteString( stream, type->name );
DaoStream_WriteChars( stream, buf );
return;
}
if( cycmap == NULL ) cycmap = DHash_New(0,0);
DMap_Insert( cycmap, self, self );
args[0] = (DaoValue*) proc->vmSpace->typeString;
args[1] = (DaoValue*) stream;
meth = DaoType_FindFunctionChars( type, "(string)" );
if( meth ){
ec = DaoProcess_Call( proc, meth, self, args, 2 );
if( ec ) ec = DaoProcess_Call( proc, meth, self, args, 1 );
}else{
meth = DaoType_FindFunctionChars( type, "serialize" );
if( meth ) ec = DaoProcess_Call( proc, meth, self, NULL, 0 );
}
if( meth == NULL ){
DaoValue_Print( self->xCinValue.value, stream, cycmap, proc );
}else if( ec ){
DaoProcess_RaiseException( proc, daoExceptionNames[ec], proc->string->chars, NULL );
}else if( meth && proc->stackValues[0] ){
DaoValue_Print( proc->stackValues[0], stream, cycmap, proc );
}else{
DaoStream_WriteString( stream, type->name );
DaoStream_WriteChars( stream, buf );
}
if( inmap == NULL ) DMap_Delete( cycmap );
}
static void DaoClass_SetupMethodFields( DaoClass *self, DaoMethodFields *mf )
{
DaoValue *cst;
DMap *overloads = DMap_New(D_STRING,0);
DNode *it, *search;
daoint i, id, pm, pm2;
for(i=0; i<mf->names->size; ++i){
DString *name = mf->names->items.pString[i];
it = DMap_Find( self->lookupTable, name );
if( it == NULL ) continue;
if( LOOKUP_ST( it->value.pInt ) != DAO_CLASS_CONSTANT ) continue;
id = LOOKUP_ID( it->value.pInt );
DMap_Insert( overloads, name, self->constants->items.pConst[id]->value );
}
for(i=0; i<mf->names->size; ++i){
DString *name = mf->names->items.pString[i];
it = DMap_Find( self->lookupTable, name );
if( it == NULL ) continue;
if( LOOKUP_ST( it->value.pInt ) != DAO_CLASS_CONSTANT ) continue;
cst = mf->routines->items.pValue[i];
search = DMap_Find( overloads, name );
if( cst == search->value.pValue ) continue;
pm = LOOKUP_PM( it->value.pInt );
pm2 = mf->perms->items.pInt[i];
if( pm2 > pm ) pm = pm2;
/*
// Add again the overloaded methods, so that a new overloading structure
// will be created for the host class. This is necessary to avoid messing
// the function calls in the methods of the mixins.
*/
DaoClass_AddConst( self, name, cst, pm );
}
DMap_Delete( overloads );
}
DaoRoutine* DaoInterface_BindTo( DaoInterface *self, DaoType *type, DMap *binds )
{
DNode *it;
DMap *newbinds = NULL;
DList *methods;
DaoRoutine *incompatible;
void *pvoid[2];
daoint i, n;
if( self->abtype->kernel->SetupMethods ){
DaoTypeKernel *kernel = self->abtype->kernel;
kernel->SetupMethods( kernel->nspace, self->abtype->core );
}
/* XXX locking */
if( type->interfaces == NULL ){
type->interfaces = DHash_New( DAO_DATA_VALUE, DAO_DATA_VALUE );
}
pvoid[0] = type;
pvoid[1] = self->abtype;
if( (it = DMap_Find( type->interfaces, self )) ) return it->value.pRoutine;
if( binds && DMap_Find( binds, pvoid ) ) return NULL;
if( binds ==NULL ) newbinds = binds = DHash_New( DAO_DATA_VOID2, 0 );
DaoInterface_TempBind( self, type, binds );
methods = DList_New(0);
DMap_SortMethods( self->methods, methods );
incompatible = DaoInterface_CheckBind( methods, type, binds );
DList_Delete( methods );
if( newbinds ) DMap_Delete( newbinds );
DMap_Insert( type->interfaces, self, incompatible );
if( incompatible ) return incompatible;
for(i=0,n=self->bases->size; i<n; i++){
DaoInterface *base = (DaoInterface*) self->bases->items.pValue[i];
if( DMap_Find( type->interfaces, base ) ) continue;
DMap_Insert( type->interfaces, base, NULL );
}
return NULL;
}
static void DMap_DeleteTimeMap( DMap *self )
{
DMap_Delete( self );
}