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;
}
static int DaoCallServer_CheckEvent( DaoTaskEvent *event, DaoFuture *fut, DaoChannel *chan )
{
DaoTaskEvent event2 = *event;
daoint i, move = 0, closed = 0;
switch( event->type ){
case DAO_EVENT_WAIT_TASKLET :
move = event->future->precond == fut;
break;
case DAO_EVENT_WAIT_RECEIVING :
if( event->channel == chan ){
move = chan->buffer->size > 0;
move |= chan->cap <= 0 && chan->buffer->size == 0;
}
break;
case DAO_EVENT_WAIT_SENDING :
move = event->channel == chan && chan->buffer->size < chan->cap;
break;
case DAO_EVENT_WAIT_SELECT :
if( event->selects == NULL ) break;
if( fut ) move |= DMap_Find( event->selects->value, fut ) != NULL;
if( chan ) move |= DMap_Find( event->selects->value, chan ) != NULL;
//move = DaoTaskEvent_CheckSelect( event );
break;
default: break;
}
return move;
}
int DaoInterface_CheckBind( DList *methods, DaoType *type, DMap *binds )
{
DNode *it;
DaoRoutine *rout2;
daoint i, n, id;
if( type->tid == DAO_OBJECT || type->tid == DAO_CLASS ){
DaoClass *klass = & type->aux->xClass;
for(i=0,n=methods->size; i<n; i++){
DaoRoutine *rout = methods->items.pRoutine[i];
rout2 = klass->initRoutines;
if( !(rout->attribs & DAO_ROUT_INITOR) ){
id = DaoClass_FindConst( klass, rout->routName );
if( id <0 ) return 0;
rout2 = (DaoRoutine*) DaoClass_GetConst( klass, id );
if( rout2->type != DAO_ROUTINE ) return 0;
}
/*printf( "AAA: %s %s\n", rout->routType->name->chars,rout2->routType->name->chars);*/
if( DaoRoutine_IsCompatible( rout2, rout->routType, binds ) ==0 ) return 0;
}
}else if( type->tid == DAO_INTERFACE ){
DaoInterface *inter = (DaoInterface*) type->aux;
for(i=0,n=methods->size; i<n; i++){
DaoRoutine *rout = methods->items.pRoutine[i];
DString *name = rout->routName;
if( rout->attribs & DAO_ROUT_INITOR ) name = inter->abtype->name;
it = DMap_Find( inter->methods, name );
if( it == NULL ) return 0;
if( DaoRoutine_IsCompatible( it->value.pRoutine, rout->routType, binds ) ==0 ) return 0;
}
}else if( type->tid == DAO_CINVALUE ){
DaoCinType *cintype = (DaoCinType*) type->aux;
for(i=0,n=methods->size; i<n; i++){
DaoRoutine *rout = methods->items.pRoutine[i];
DString *name = rout->routName;
if( rout->attribs & DAO_ROUT_INITOR ) name = cintype->vatype->name;
it = DMap_Find( cintype->methods, name );
if( it == NULL ) return 0;
if( DaoRoutine_IsCompatible( it->value.pRoutine, rout->routType, binds ) ==0 ) return 0;
}
}else{
for(i=0,n=methods->size; i<n; i++){
DaoRoutine *rout = methods->items.pRoutine[i];
DString *name = rout->routName;
DaoRoutine *func;
if( rout->attribs & DAO_ROUT_INITOR ) name = type->name;
func = DaoType_FindFunction( type, name );
if( func == NULL ) return 0;
if( DaoRoutine_IsCompatible( func, rout->routType, binds ) ==0 ) return 0;
}
}
return 1;
}
static void DaoMT_Critical( DaoProcess *proc, DaoValue *p[], int n )
{
void *key;
DNode *it;
DMap *cache = (DMap*) DaoProcess_GetAuxData( proc, DaoMT_ProcMutexCache );
DaoVmCode *sect = DaoProcess_InitCodeSection( proc, 0 );
DaoRoutine *routine = proc->activeRoutine;
if( sect == NULL ) return;
/* Get the original routine, if this one is a specialized copy: */
while( routine->original ) routine = routine->original;
/*
// Use "routine + sect->c" instead of "sect" as the key for mutex,
// as "sect" may be different for different copy of specialized routine.
// But "sect->c" won't change after being set during compiling.
*/
key = routine + sect->c;
if( cache == NULL ){
cache = DHash_New(0,0); /* Local cache is used to avoid extra locking; */
DaoProcess_SetAuxData( proc, DaoMT_ProcMutexCache, cache );
}
it = DMap_Find( cache, key ); /* Check local cache first; */
if( it == NULL ) it = DMap_Insert( cache, key, DaoMT_GetMutex( routine, key ) );
DMutex_Lock( (DMutex*) it->value.pVoid );
DaoProcess_Execute( proc );
DMutex_Unlock( (DMutex*) it->value.pVoid );
DaoProcess_PopFrame( proc );
}
int DaoObject_GetData( DaoObject *self, DString *name, DaoValue **data, DaoObject *othis )
{
DNode *node;
DaoValue *p = NULL;
DaoClass *klass = self->defClass;
DaoObject *null = & klass->objType->value->xObject;
int child = othis && DaoObject_ChildOf( (DaoValue*)othis, (DaoValue*)self );
int id, st, up, pm, access;
*data = NULL;
node = DMap_Find( self->defClass->lookupTable, name );
if( node == NULL ) return DAO_ERROR_FIELD_NOTEXIST;
pm = LOOKUP_PM( node->value.pInt );
st = LOOKUP_ST( node->value.pInt );
up = LOOKUP_UP( node->value.pInt );
id = LOOKUP_ID( node->value.pInt );
if( self == null && st == DAO_OBJECT_VARIABLE ) return DAO_ERROR_FIELD_NOTPERMIT;
access = othis == self || pm == DAO_PERM_PUBLIC || (child && pm >= DAO_PERM_PROTECTED);
if( access == 0 ) return DAO_ERROR_FIELD_NOTPERMIT;
switch( st ){
case DAO_OBJECT_VARIABLE : p = self->objValues[id]; break;
case DAO_CLASS_VARIABLE : p = klass->variables->items.pVar[id]->value; break;
case DAO_CLASS_CONSTANT : p = klass->constants->items.pConst[id]->value; break;
default : break;
}
*data = p;
return 0;
}
static void DaoObject_Print( DaoValue *self0, DaoProcess *proc, DaoStream *stream, DMap *cycData )
{
int ec;
char buf[50];
DaoObject *self = & self0->xObject;
sprintf( buf, "[%p]", self );
if( self0 == self->defClass->objType->value ){
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, "[null]" );
return;
}
if( cycData != NULL && DMap_Find( cycData, self ) != NULL ){
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, buf );
return;
}
if( cycData ) MAP_Insert( cycData, self, self );
DString_SetChars( proc->mbstring, "serialize" );
DaoValue_Clear( & proc->stackValues[0] );
ec = DaoObject_InvokeMethod( self, proc->activeObject, proc, proc->mbstring, NULL,0,1,1 );
if( ec && ec != DAO_ERROR_FIELD_NOTEXIST ){
DaoProcess_RaiseException( proc, daoExceptionNames[ec], proc->mbstring->chars, NULL );
}else if( ec == DAO_ERROR_FIELD_NOTEXIST || proc->stackValues[0] == NULL ){
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, buf );
}else{
DaoValue_Print( proc->stackValues[0], proc, stream, cycData );
}
}
DaoxGlyph* DaoxFont_GetGlyph( DaoxFont *self, size_t codepoint )
{
DNode *node = DMap_Find( self->glyphs, (void*) codepoint );
if( node ) return (DaoxGlyph*) node->value.pVoid;
return DaoxFont_LoadGlyph( self, codepoint );
}
static DaoComplex* DaoProcess_GetTimeData( DaoProcess *self, DaoStackFrame *frame )
{
DaoComplex com = {DAO_COMPLEX,0,0,0,1,{0.0,0.0}};
DMap *mapTime = DaoProcess_GetTimeMap( self );
DNode *it = DMap_Find( mapTime, frame );
if( it == NULL ) it = DMap_Insert( mapTime, frame, & com );
return (DaoComplex*) it->value.pValue;
}
/* Find a leaf at the level.
*/
static DMacroNode* DMacroNode_FindLeaf( DMacroNode *self, DMap *check, int level )
{
DNode *used = DMap_Find( check, self );
DMacroNode *node;
daoint j;
/* for variable not in a group */
if( self->level == level+1 && self->leaves->size && used ==NULL ) return self;
for(j=0; j<self->nodes->size; j++){
node = (DMacroNode*) self->nodes->items.pVoid[j];
if( node->level == level+1 ){ /* leaf is a node inside of a node */
used = DMap_Find( check, node );
if( node->leaves->size && used == NULL ) return node;
}
node = DMacroNode_FindLeaf( node, check, level );
if( node ) return node;
}
return NULL;
}
static int DaoClass_MapIndex( DaoClass *mixin, int st, int id, DMap *mixed )
{
int offset = 0;
DaoClass *mx = DaoClass_FindMixin( mixin, st, id, & offset );
DNode *it = DMap_Find( mixed, mx );
if( it != NULL ) it = MAP_Find( it->value.pMap, LOOKUP_BIND( st, 0, 0, id-offset ) );
if( it != NULL ) return LOOKUP_ID( it->value.pInt );
return id;
}
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;
}
static DMutex* DaoMT_GetMutex( DaoRoutine *routine, void *key )
{
DNode *it;
DMap *mutexes;
DMutex *mutex = NULL;
DMutex_Lock( & mainVmSpace->miscMutex );
it = DMap_Find( routine->body->aux, DaoMT_RoutMutexSet );
if( it == NULL ) it = DMap_Insert( routine->body->aux, DaoMT_RoutMutexSet, DHash_New(0,0) );
mutexes = (DMap*) it->value.pVoid;
it = DMap_Find( mutexes, key );
if( it == NULL ){
mutex = (DMutex*) dao_calloc(1,sizeof(DMutex));
DMutex_Init( mutex );
DMap_Insert( mutexes, key, mutex );
}else{
mutex = (DMutex*) it->value.pVoid;
}
DMutex_Unlock( & mainVmSpace->miscMutex );
return mutex;
}
daoint DaoxDataFrame_GetIndex( DaoxDataFrame *self, int dim, const char *label )
{
DString slab = DString_WrapMBS( label );
DMap *labmap = NULL;
DNode *it;
if( dim < 0 || dim >= 3 ) return -1;
if( self->groups[dim] >= self->labels[dim]->size ) return -1;
labmap = self->labels[dim]->items.pMap[ self->groups[dim] ];
it = labmap == NULL ? NULL : DMap_Find( labmap, & slab );
if( it ) return it->value.pInt;
return -1;
}
void DaoValue_SetType( DaoValue *to, DaoType *tp )
{
DaoVmSpace *vms;
DaoType *tp2;
DNode *it;
if( to->type != tp->tid && tp->tid != DAO_ANY ) return;
if( tp->attrib & DAO_TYPE_SPEC ) return;
switch( to->type ){
#ifdef DAO_WITH_NUMARRAY
case DAO_ARRAY :
if( to->xArray.size ) return;
if( tp->tid != DAO_ARRAY || tp->args == NULL || tp->args->size == 0 ) break;
tp = tp->args->items.pType[0];
if( tp->tid == DAO_NONE || tp->tid > DAO_COMPLEX ) break;
DaoArray_SetNumType( (DaoArray*) to, tp->tid );
break;
#endif
case DAO_LIST :
/* var x: any = {}, x->ctype should be list<any> */
if( tp->tid == DAO_ANY ){
vms = DaoType_GetVmSpace( tp );
tp = vms->typeListAny;
}
if( to->xList.ctype && !(to->xList.ctype->attrib & DAO_TYPE_UNDEF) ) break;
GC_Assign( & to->xList.ctype, tp );
break;
case DAO_MAP :
if( tp->tid == DAO_ANY ){
vms = DaoType_GetVmSpace( tp );
tp = vms->typeMapAny;
}
if( to->xMap.ctype && !(to->xMap.ctype->attrib & DAO_TYPE_UNDEF) ) break;
GC_Assign( & to->xMap.ctype, tp );
break;
case DAO_TUPLE :
tp2 = to->xTuple.ctype;
if( tp->tid == DAO_ANY ) break;
if( tp->args->size ==0 ) break; /* not to the generic tuple type */
if( tp2 == NULL || tp2->mapNames == NULL || tp2->mapNames->size ==0 ){
GC_Assign( & to->xTuple.ctype, tp );
break;
}
if( tp->mapNames == NULL || tp->mapNames->size ) break;
for(it=DMap_First(tp2->mapNames); it!=NULL; it=DMap_Next(tp2->mapNames, it)){
if( DMap_Find( tp->mapNames, it->key.pVoid ) == NULL ) break;
}
if( it ) break;
GC_Assign( & to->xTuple.ctype, tp );
break;
default : break;
}
}
static void DaoInterface_TempBind( DaoInterface *self, DaoType *type, DMap *binds )
{
daoint i, N = self->supers->size;
void *pvoid[2];
pvoid[0] = type;
pvoid[1] = self->abtype;
if( DMap_Find( binds, pvoid ) ) return;
DMap_Insert( binds, pvoid, NULL );
for(i=0; i<N; i++){
DaoInterface *super = (DaoInterface*) self->supers->items.pValue[i];
DaoInterface_TempBind( super, type, binds );
}
}
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 int DaoInterface_CheckMethod( DaoRoutine *routine, DaoType *type, DMap *binds )
{
DaoRoutine *method = NULL;
DNode *it;
if( type->tid == DAO_OBJECT || type->tid == DAO_CLASS ){
DaoClass *klass = & type->aux->xClass;
method = klass->initRoutines;
if( !(routine->attribs & DAO_ROUT_INITOR) ){
int id = DaoClass_FindConst( klass, routine->routName );
if( id <0 ) return 0;
method = (DaoRoutine*) DaoClass_GetConst( klass, id );
if( method->type != DAO_ROUTINE ) return 0;
}
}else if( type->tid == DAO_INTERFACE ){
DaoInterface *inter = (DaoInterface*) type->aux;
DString *name = routine->routName;
if( routine->attribs & DAO_ROUT_INITOR ) name = inter->abtype->name;
it = DMap_Find( inter->methods, name );
if( it != NULL ) method = it->value.pRoutine;
}else if( type->tid == DAO_CINVALUE ){
DaoCinType *cintype = (DaoCinType*) type->aux;
DString *name = routine->routName;
if( routine->attribs & DAO_ROUT_INITOR ) name = cintype->vatype->name;
it = DMap_Find( cintype->methods, name );
if( it == NULL && cintype->target != NULL ){
return DaoInterface_CheckMethod( routine, cintype->target, binds );
}
if( it != NULL ) method = it->value.pRoutine;
}else{
DString *name = routine->routName;
if( routine->attribs & DAO_ROUT_INITOR ) name = type->name;
method = DaoType_FindFunction( type, name );
}
if( method == NULL ) return 0;
/*printf( "AAA: %s %s\n", routine->routType->name->chars,method->routType->name->chars);*/
return DaoRoutine_IsCompatible( method, routine->routType, binds );
}
int DaoType_MatchInterface( DaoType *self, DaoInterface *inter, DMap *binds )
{
DMap *inters = self->interfaces;
DNode *it;
if( inter == NULL ) return DAO_MT_NOT;
if( inters == NULL ){
return DAO_MT_SUB * (DaoInterface_BindTo( inter, self, binds ) == NULL);
}
if( (it = DMap_Find( inters, inter )) ){
return it->value.pRoutine ? DAO_MT_NOT : DAO_MT_SUB;
}
return DAO_MT_SUB * (DaoInterface_BindTo( inter, self, binds ) == NULL);
}
int DaoType_MatchInterface( DaoType *self, DaoInterface *inter, DMap *binds )
{
DMap *inters = self->interfaces;
DNode *it;
daoint i;
if( inter == NULL ) return DAO_MT_NOT;
if( inter->abtype->kernel->SetupMethods ){
DaoTypeKernel *kernel = inter->abtype->kernel;
kernel->SetupMethods( kernel->nspace, kernel->typer );
}
if( inters == NULL ) return DAO_MT_SUB * DaoInterface_BindTo( inter, self, binds );
if( (it = DMap_Find( inters, inter )) ) return it->value.pVoid ? DAO_MT_SUB : DAO_MT_NOT;
return DAO_MT_SUB * DaoInterface_BindTo( inter, self, binds );
}
int DaoXmlParser_ParseFormatedChar( DaoXmlParser *self, DString *string )
{
DNode *it;
if( *self->source != '&' ){
DString_AppendChar( string, *self->source );
self->source += 1;
return 0;
}
if( DaoXmlParser_ParseEscapedChar( self, self->escape ) ) return 1;
it = DMap_Find( self->escapes, self->escape );
if( it == NULL ) return 1;
DString_Append( string, it->value.pString );
return 0;
}
static void DaoxProfiler_Update( DaoxProfiler *self, DaoStackFrame *frame, double time )
{
DaoComplex com = {DAO_COMPLEX,0,0,0,1,{0.0,0.0}};
DaoRoutine *caller = frame->prev ? frame->prev->routine : NULL;
DaoRoutine *callee = frame->routine;
DNode *it, *it2;
if( frame->returning == 0xffff ) caller = NULL;
while( caller && caller->original ) caller = caller->original;
while( callee && callee->original ) callee = callee->original;
DMutex_Lock( & self->mutex );
{
it = DMap_Find( self->profile, callee );
if( it == NULL ) it = DMap_Insert( self->profile, callee, self->one );
it2 = DMap_Find( it->value.pMap, caller );
if( it2 == NULL ) it2 = DMap_Insert( it->value.pMap, caller, & com );
it2->value.pValue->xComplex.value.real += time;
it2->value.pValue->xComplex.value.imag += 1;
}
DMutex_Unlock( & self->mutex );
}
void DaoValue_SetType( DaoValue *to, DaoType *tp )
{
DaoType *tp2;
DNode *it;
if( to->type != tp->tid && tp->tid != DAO_ANY ) return;
if( tp->attrib & DAO_TYPE_SPEC ) return;
switch( to->type ){
#ifdef DAO_WITH_NUMARRAY
case DAO_ARRAY :
if( to->xArray.size ) return;
if( tp->tid != DAO_ARRAY || tp->nested == NULL || tp->nested->size == 0 ) break;
tp = tp->nested->items.pType[0];
if( tp->tid == DAO_NONE || tp->tid > DAO_COMPLEX ) break;
DaoArray_SetNumType( (DaoArray*) to, tp->tid );
break;
#endif
case DAO_LIST :
/* v : any = {}, v->unitype should be list<any> */
if( tp->tid == DAO_ANY ) tp = dao_list_any;
if( to->xList.unitype && !(to->xList.unitype->attrib & DAO_TYPE_UNDEF) ) break;
GC_ShiftRC( tp, to->xList.unitype );
to->xList.unitype = tp;
break;
case DAO_MAP :
if( tp->tid == DAO_ANY ) tp = dao_map_any;
if( to->xMap.unitype && !(to->xMap.unitype->attrib & DAO_TYPE_UNDEF) ) break;
GC_ShiftRC( tp, to->xMap.unitype );
to->xMap.unitype = tp;
break;
case DAO_TUPLE :
tp2 = to->xTuple.unitype;
if( tp->tid == DAO_ANY ) break;
if( tp->nested->size ==0 ) break; /* not to the generic tuple type */
if( tp2 == NULL || tp2->mapNames == NULL || tp2->mapNames->size ==0 ){
GC_ShiftRC( tp, to->xTuple.unitype );
to->xTuple.unitype = tp;
break;
}
if( tp->mapNames == NULL || tp->mapNames->size ) break;
for(it=DMap_First(tp2->mapNames); it!=NULL; it=DMap_Next(tp2->mapNames, it)){
if( DMap_Find( tp->mapNames, it->key.pVoid ) == NULL ) break;
}
if( it ) break;
GC_ShiftRC( tp, to->xTuple.unitype );
to->xTuple.unitype = tp;
break;
default : break;
}
}
static void DaoClass_SetField( DaoValue *self0, DaoProcess *proc, DString *name, DaoValue *value )
{
DaoClass *self = & self0->xClass;
DNode *node = DMap_Find( self->lookupTable, name );
if( node && LOOKUP_ST( node->value.pInt ) == DAO_CLASS_VARIABLE ){
int up = LOOKUP_UP( node->value.pInt );
int id = LOOKUP_ID( node->value.pInt );
DaoVariable *dt = self->variables->items.pVar[id];
if( DaoValue_Move( value, & dt->value, dt->dtype ) ==0 )
DaoProcess_RaiseException( proc, DAO_ERROR_PARAM, "not matched" );
}else{
/* XXX permission */
DaoProcess_RaiseException( proc, DAO_ERROR_FIELD, "not exist" );
}
}
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;
}
DaoCinType* DaoInterface_GetConcrete( DaoInterface *self, DaoType *type )
{
DNode *it;
if( self->concretes == NULL ) return NULL;
it = DMap_Find( self->concretes, type );
if( it == NULL ){
for(it=DMap_First(self->concretes); it; it=DMap_Next(self->concretes,it)){
if( DaoType_MatchTo( it->key.pType, type, NULL ) >= DAO_MT_EQ ){
return (DaoCinType*) it->value.pVoid;
}
}
return NULL;
}
return (DaoCinType*) it->value.pVoid;
}
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 );
}
void DaoClass_ResetAttributes( DaoClass *self )
{
DNode *node;
DString *mbs = DString_New(1);
int i, k, id, autodef = self->classRoutines->overloads->routines->size == 0;
DaoClass_MakeInterface( self );
for(i=0; i<self->classRoutines->overloads->routines->size; i++){
DaoRoutine *r2 = self->classRoutines->overloads->routines->items.pRoutine[i];
DArray *types = r2->routType->nested;
autodef = r2->parCount == 0;
if( autodef ) break;
for(k=0; k<types->size; k++){
int tid = types->items.pType[k]->tid;
if( tid != DAO_PAR_DEFAULT && tid != DAO_PAR_VALIST ) break;
}
autodef = k == types->size;
if( autodef ) break;
}
if( autodef && self->parent ){
if( self->parent->type == DAO_CLASS ){
DaoClass *klass = (DaoClass*) self->parent;
autodef = autodef && (klass->attribs & DAO_CLS_AUTO_DEFAULT);
}else{
autodef = 0;
}
}
#if 0
printf( "%s %i\n", self->className->mbs, autodef );
#endif
if( autodef ) self->attribs |= DAO_CLS_AUTO_DEFAULT;
for(i=DVM_NOT; i<=DVM_BITRIT; i++){
DString_SetMBS( mbs, daoBitBoolArithOpers[i-DVM_NOT] );
node = DMap_Find( self->lookupTable, mbs );
if( node == NULL ) continue;
if( LOOKUP_ST( node->value.pInt ) != DAO_CLASS_CONSTANT ) continue;
id = LOOKUP_ID( node->value.pInt );
k = self->constants->items.pConst[id]->value->type;
if( k != DAO_ROUTINE ) continue;
self->attribs |= DAO_OPER_OVERLOADED | (DAO_OPER_OVERLOADED<<(i-DVM_NOT+1));
}
DString_Delete( mbs );
}
static int addStringFromMap( DaoValue *self, DString *S, DaoMap *sym, const char *key, int id )
{
DNode *node;
if( S==NULL || sym==NULL ) return 0;
DString_SetMBS( self->xString.data, key );
node = DMap_Find( sym->items, & self );
if( node ){
DaoList *list = & node->value.pValue->xList;
if( list->type == DAO_LIST && list->items.size > id ){
DaoValue *p = list->items.items.pValue[ id ];
if( p->type == DAO_STRING ){
DString_Append( S, p->xString.data );
return 1;
}
}
}
return 0;
}
static void DaoObject_Print( DaoValue *self0, DaoProcess *proc, DaoStream *stream, DMap *cycData )
{
int ec = 0;
char buf[50];
DaoObject *self = & self0->xObject;
DaoValue *params[2];
DaoRoutine *meth;
sprintf( buf, "[%p]", self );
if( self0 == self->defClass->objType->value ){
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, "[null]" );
return;
}
if( cycData != NULL && DMap_Find( cycData, self ) != NULL ){
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, buf );
return;
}
if( cycData ) MAP_Insert( cycData, self, self );
DaoValue_Clear( & proc->stackValues[0] );
params[0] = (DaoValue*) dao_type_string;
params[1] = (DaoValue*) stream;
meth = DaoClass_FindMethod( self->defClass, "(string)", NULL );
if( meth ){
ec = DaoProcess_Call( proc, meth, self0, params, 2 );
if( ec ) ec = DaoProcess_Call( proc, meth, self0, params, 1 );
}else{
meth = DaoClass_FindMethod( self->defClass, "serialize", NULL );
if( meth ) ec = DaoProcess_Call( proc, meth, self0, NULL, 0 );
}
if( ec ){
DaoProcess_RaiseException( proc, daoExceptionNames[ec], proc->string->chars, NULL );
}else if( meth && proc->stackValues[0] ){
DaoValue_Print( proc->stackValues[0], proc, stream, cycData );
}else{
DaoStream_WriteString( stream, self->defClass->className );
DaoStream_WriteChars( stream, buf );
}
}
