void DaoxNode_Delete( DaoxNode *self )
{
DaoCstruct_Free( (DaoCstruct*) self );
if( self->ins ) DList_Delete( self->ins );
DList_Delete( self->outs );
dao_free( self );
}
void DaoxGraph_Delete( DaoxGraph *self )
{
DaoCstruct_Free( (DaoCstruct*) self );
DList_Delete( self->nodes );
DList_Delete( self->edges );
GC_DecRC( self->nodeType );
GC_DecRC( self->edgeType );
dao_free( self );
}
void DaoxTriangulator_Delete( DaoxTriangulator *self )
{
DaoxVertexData *vertex;
DaoxTriangulator_Reset( self );
vertex = self->caches;
while( vertex ){
DaoxVertexData *v = vertex;
vertex = vertex->next;
DaoxVertexData_Delete( v );
}
DArray_Delete( self->points );
DArray_Delete( self->triangles );
DList_Delete( self->vertices );
DList_Delete( self->worklist );
dao_free( self );
}
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;
}
/*
// Activate all events waiting on a future value:
*/
void DaoFuture_ActivateEvent( DaoFuture *self )
{
DaoCallServer *server = daoCallServer;
DList *array = DList_New(0);
DNode *node;
daoint i;
DMutex_Lock( & server->mutex );
for(i=0; i<server->events2->size; ++i){
DaoTaskEvent *event = (DaoTaskEvent*) server->events2->items.pVoid[i];
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DList_Append( server->events, event );
DList_Erase( server->events2, i, 1 );
i -= 1;
}
}
for(node=DMap_First(server->waitings); node; node=DMap_Next(server->waitings,node)){
DaoTaskEvent *event = (DaoTaskEvent*) node->value.pValue;
/* remove from timed waiting list: */
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DList_Append( server->events, event );
DList_Append( array, node->key.pVoid );
}
}
for(i=0; i<array->size; i++) DMap_Erase( server->waitings, array->items.pVoid[i] );
DCondVar_Signal( & server->condv );
DMutex_Unlock( & server->mutex );
DList_Delete( array );
}
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 DaoXmlDOM_Delete( DaoXmlDOM *self )
{
daoint i;
DaoXmlDOM_Reset( self );
for(i=0; i<self->caches->size; ++i){
DaoXmlNode_Delete( (DaoXmlNode*) self->caches->items.pVoid[i] );
}
DList_Delete( self->caches );
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 );
}
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 );
}
int DaoRegex_ChangeExt( DaoRegex *self, DString *input, DString *output,
DString *target, int index, daoint *start2, daoint *end2 )
{
daoint start = start2 ? (daoint) *start2 : 0;
daoint end = end2 ? (daoint) *end2 : 0;
daoint i, n=0, p1=start, p2=end, p3, last;
DaoValue *value = NULL;
DaoString matched = {DAO_STRING,0,0,0,0,NULL};
DList *array = DList_New( DAO_DATA_VALUE );
DString *tmp = DString_New();
DString *tmp2 = DString_New();
DString_Reset( output, 0 );
if( self == NULL || input->size == 0 ) goto DoNothing;
matched.value = tmp;
Dao_ParseTarget( target, array, (DaoValue*) & matched );
if( end == 0 ) end = p2 = DString_Size( input );
n = last = 0;
while( DaoRegex_Match( self, input, & p1, & p2 ) ){
n += 1;
if( index ==0 || n == index ){
DString_SubString( input, tmp2, last, p1 - last );
DString_Append( output, tmp2 );
DString_Clear( tmp );
for(i=0; i<array->size; i++){
value = array->items.pValue[i];
if( value->type == DAO_INTEGER ){
if( DaoRegex_SubMatch( self, value->xInteger.value, & p1, & p3 ) ){
DString_SubString( input, tmp2, p1, p3 - p1 );
DString_Append( tmp, tmp2 );
}
}else{
DString_Append( tmp, value->xString.value );
}
}
DString_Append( output, tmp );
last = p2;
}
if( start2 ) *start2 = p1;
if( end2 ) *end2 = p2;
p1 = p2;
p2 = end;
if( index && n == index ) break;
}
DString_SubString( input, tmp2, last, end - last );
DString_Append( output, tmp2 );
DoNothing:
DString_Delete( tmp );
DString_Delete( tmp2 );
DList_Delete( array );
return n;
}
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 );
}
static void DList_DeleteItem( DList *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_ARRAY : DArray_Delete( (DArray*) item ); break;
case DAO_DATA_LIST : DList_Delete( (DList*) item ); break;
case DAO_DATA_MAP : DMap_Delete( (DMap*) item ); break;
default : break;
}
}
static double DaoxGraph_MaxFlow_PRTF_Float( DaoxGraph *self, DaoxNode *source, DaoxNode *sink )
{
daoint i, n;
double inf = 1.0;
DList *list = DList_New(0);
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) inf += edge->X.MF->capacity;
}
for(i=0,n=self->nodes->size; i<n; i++){
DaoxNode *node = self->nodes->items.pgNode[i];
node->X.MF->nextpush = 0;
node->X.MF->height = 0;
node->X.MF->excess = 0.0;
if( node != source && node != sink ) DList_PushBack( list, node );
}
source->X.MF->nextpush = 0;
source->X.MF->height = n;
source->X.MF->excess = inf;
for(i=0,n=self->edges->size; i<n; i++){
DaoxEdge *edge = self->edges->items.pgEdge[i];
edge->X.MF->flow_fw = 0.0;
edge->X.MF->flow_bw = 0.0;
}
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) MaxFlow_PushFloat( source, edge );
}
i = 0;
while( i < list->size ){
DaoxNode *U = list->items.pgNode[i];
daoint old_height = U->X.MF->height;
MaxFlow_DischargeFloat( U );
if( U->X.MF->height > old_height ){
DList_Erase( list, i, 1 );
DList_PushFront( list, U );
i = 0;
}else{
i += 1;
}
}
DList_Delete( list );
inf = 0.0;
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) inf += edge->X.MF->flow_fw;
}
return inf;
}
static void DList_DeleteItems( DList *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_ARRAY : for(i=M; i<N; i++) DArray_Delete( self->items.pArray[i] ); break;
case DAO_DATA_LIST : for(i=M; i<N; i++) DList_Delete( self->items.pList[i] ); break;
case DAO_DATA_MAP : for(i=M; i<N; i++) DMap_Delete( self->items.pMap[i] ); break;
default : break;
}
}
static void NODE_Search( DaoProcess *proc, DaoValue *p[], int N )
{
DList *nodes;
DaoList *list = DaoProcess_PutList( proc );
DaoxNode *self = (DaoxNode*) p[0];
DaoVmCode *sect = DaoProcess_InitCodeSection( proc, 1 );
daoint method = p[1]->xEnum.value;
daoint which = p[2]->xEnum.value;
daoint i, j, entry;
if( sect == NULL ) return;
for(i=0; i<self->graph->nodes->size; i++){
DaoxNode *node = (DaoxNode*) self->graph->nodes->items.pVoid[i];
node->state = 0;
}
nodes = DList_New(0);
DList_PushBack( nodes, self );
entry = proc->topFrame->entry;
while( nodes->size ){
DaoxNode *node = NULL;
if( method ){
node = (DaoxNode*) DList_Front( nodes );
DList_PopFront( nodes );
}else{
node = (DaoxNode*) DList_Back( nodes );
DList_PopBack( nodes );
}
if( node->state ) continue;
node->state = 1;
if( sect->b >0 ) DaoProcess_SetValue( proc, sect->a, (DaoValue*) node );
proc->topFrame->entry = entry;
DaoProcess_Execute( proc );
if( proc->status == DAO_PROCESS_ABORTED ) break;
if( proc->stackValues[0]->xInteger.value ){
DaoList_PushBack( list, (DaoValue*) node );
if( which == 0 ) break;
}
for(j=0; j<node->outs->size; j++){
DaoxEdge *edge = (DaoxEdge*) node->outs->items.pVoid[j];
DaoxNode *node2 = node == edge->first ? edge->second : edge->first;
DList_PushBack( nodes, node2 );
}
}
DaoProcess_PopFrame( proc );
DList_Delete( nodes );
}
static void GRAPH_ConnectedComponents( DaoProcess *proc, DaoValue *p[], int N )
{
DaoxGraph *self = (DaoxGraph*) p[0];
DaoList *graphs = DaoProcess_PutList( proc );
DList *cclist;
daoint i, n;
if( self->nodes->size == 0 ){
DaoList_PushBack( graphs, (DaoValue*)self );
return;
}
cclist = DList_New(0);
DaoxGraph_ConnectedComponents( self, cclist );
for(i=0,n=cclist->size; i<n; i++) DaoList_PushBack( graphs, cclist->items.pValue[i] );
DList_Delete( cclist );
}
void DaoxNode_DepthFirstSearch( DaoxNode *self, DList *nodes )
{
DList *stack = DList_New(0);
daoint j;
DList_Clear( nodes );
DList_PushBack( stack, self );
while( stack->size ){
DaoxNode *node = (DaoxNode*) DList_Back( stack );
DList_PopBack( stack );
if( node->state ) continue;
node->state = 1;
DList_PushBack( nodes, node );
for(j=0; j<node->outs->size; j++){
DaoxEdge *edge = (DaoxEdge*) node->outs->items.pVoid[j];
DaoxNode *node2 = node == edge->first ? edge->second : edge->first;
DList_PushBack( stack, node2 );
}
}
DList_Delete( stack );
}
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 DaoChannel_Delete( DaoChannel *self )
{
DaoCstruct_Free( (DaoCstruct*) self );
DList_Delete( self->buffer );
dao_free( self );
}
void DCondVar_Destroy( DCondVar *self )
{
DList_Delete( self->thdWaiting );
DMutex_Destroy( & self->thdMutex );
CloseHandle( self->myCondVar );
}
void DaoxGraph_ConnectedComponents( DaoxGraph *self, DList *cclist )
{
DList *nodes;
DaoxGraph *subgraph;
daoint i, j, k, n;
if( self->nodes->size == 0 ){
DList_PushBack( cclist, self );
return;
}
for(i=0; i<self->nodes->size; i++){
DaoxNode *node = (DaoxNode*) self->nodes->items.pVoid[i];
node->state = 0;
}
nodes = DList_New(0);
while( self->nodes->size ){
DaoxNode_BreadthFirstSearch( (DaoxNode*) self->nodes->items.pVoid[0], nodes );
#if 0
printf( "self->nodes->size = %i, %i\n", self->nodes->size, nodes->size );
#endif
if( nodes->size == self->nodes->size ){
DList_PushBack( cclist, self );
break;
}
subgraph = DaoxGraph_New( self->ctype, self->directed );
DList_PushBack( cclist, subgraph );
for(i=0,n=nodes->size; i<n; i++){
DaoxNode *node = (DaoxNode*) nodes->items.pVoid[i];
GC_Assign( & node->graph, subgraph );
DList_PushBack( subgraph->nodes, node );
for(j=0; j<node->outs->size; j++){
DaoxEdge *edge = (DaoxEdge*) node->outs->items.pVoid[j];
if( edge->graph == subgraph ) continue;
GC_Assign( & edge->graph, subgraph );
DList_PushBack( subgraph->edges, edge );
}
}
for(i=0,k=0,n=self->nodes->size; i<n; i++){
DaoxNode *node = (DaoxNode*) self->nodes->items.pVoid[i];
/* Ensure no duplication of the reference (for the Concurrent GC): */
self->nodes->items.pVoid[i] = NULL;
if( node->graph != self ){
GC_DecRC( node );
continue;
}
self->nodes->items.pVoid[k++] = node;
}
self->nodes->size = k;
for(i=0,k=0,n=self->edges->size; i<n; i++){
DaoxNode *edge = (DaoxNode*) self->edges->items.pVoid[i];
/* Ensure no duplication of the reference (for the Concurrent GC): */
self->edges->items.pVoid[i] = NULL;
if( edge->graph != self ){
GC_DecRC( edge );
continue;
}
self->edges->items.pVoid[k++] = edge;
}
self->edges->size = k;
}
DList_Delete( nodes );
}
