自学教程：C++ D_MAGIC_CLEAR函数代码示例

voiddfb_surfacemanager_destroy( SurfaceManager *manager ){     Chunk *chunk;     D_ASSERT( manager != NULL );     D_ASSERT( manager->chunks != NULL );     D_MAGIC_ASSERT( manager, SurfaceManager );     D_MAGIC_CLEAR( manager );     /* Deallocate all chunks. */     chunk = manager->chunks;     while (chunk) {          Chunk *next = chunk->next;          D_MAGIC_CLEAR( chunk );          SHFREE( chunk );          chunk = next;     }     /* Destroy manager lock. */     fusion_skirmish_destroy( &manager->lock );     /* Deallocate manager struct. */     SHFREE( manager );}

static DFBResultdfb_clipboard_core_shutdown( DFBClipboardCore *data,                             bool              emergency ){     DFBClipboardCoreShared *shared;     D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_shutdown( %p, %semergency )/n", data, emergency ? "" : "no " );     D_MAGIC_ASSERT( data, DFBClipboardCore );     shared = data->shared;     D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );     fusion_skirmish_destroy( &shared->lock );     if (shared->data)          SHFREE( shared->shmpool, shared->data );     if (shared->mime_type)          SHFREE( shared->shmpool, shared->mime_type );     D_MAGIC_CLEAR( data );     D_MAGIC_CLEAR( shared );     return DFB_OK;}

DirectResultfusion_shm_deinit( FusionWorld *world ){     int              i;     DirectResult     ret;     FusionSHM       *shm;     FusionSHMShared *shared;     D_MAGIC_ASSERT( world, FusionWorld );     shm = &world->shm;     D_MAGIC_ASSERT( shm, FusionSHM );     shared = shm->shared;     D_MAGIC_ASSERT( shared, FusionSHMShared );     ret = fusion_skirmish_prevail( &shared->lock );     if (ret)          return ret;     /* Deinitialize shared data. */     if (fusion_master( world )) {          D_ASSUME( shared->num_pools == 0 );          for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {               if (shared->pools[i].active) {                    D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );                    D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );                    D_WARN( "destroying remaining '%s'", shared->pools[i].name );                    fusion_shm_pool_destroy( world, &shared->pools[i] );               }          }          /* Destroy shared lock. */          fusion_skirmish_destroy( &shared->lock );          D_MAGIC_CLEAR( shared );     }     else {          for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {               if (shared->pools[i].active) {                    D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );                    D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );                    fusion_shm_pool_detach( shm, &shared->pools[i] );               }          }          fusion_skirmish_dismiss( &shared->lock );     }     D_MAGIC_CLEAR( shm );     return DR_OK;}

static Chunk*free_chunk( SurfaceManager *manager, Chunk *chunk ){     D_MAGIC_ASSERT( manager, SurfaceManager );     D_MAGIC_ASSERT( chunk, _Chunk_ );     if (!chunk->buffer) {          D_BUG( "freeing free chunk" );          return chunk;     }     else {          D_DEBUG_AT( Core_SM, "Deallocating %d bytes at offset %d./n",                      chunk->length, chunk->offset );     }     if (chunk->buffer->policy == CSP_VIDEOONLY)          manager->available += chunk->length;     chunk->buffer = NULL;     manager->min_toleration--;     if (chunk->prev  &&  !chunk->prev->buffer) {          Chunk *prev = chunk->prev;          //D_DEBUG_AT( Core_SM, "  -> merging with previous chunk at %d/n", prev->offset );          prev->length += chunk->length;          prev->next = chunk->next;          if (prev->next)               prev->next->prev = prev;          //D_DEBUG_AT( Core_SM, "  -> freeing %p (prev %p, next %p)/n", chunk, chunk->prev, chunk->next);          D_MAGIC_CLEAR( chunk );          SHFREE( chunk );          chunk = prev;     }     if (chunk->next  &&  !chunk->next->buffer) {          Chunk *next = chunk->next;          //D_DEBUG_AT( Core_SM, "  -> merging with next chunk at %d/n", next->offset );          chunk->length += next->length;          chunk->next = next->next;          if (chunk->next)               chunk->next->prev = chunk;          D_MAGIC_CLEAR( next );          SHFREE( next );     }     return chunk;}

static voidcall_handlers( int   num,               void *addr ){     DirectLink   *l, *n;     if (num == SIG_DUMP_STACK)          num = DIRECT_SIGNAL_DUMP_STACK;     /* Loop through all handlers. */     direct_mutex_lock( &handlers_lock );     direct_list_foreach_safe (l, n, handlers) {          DirectSignalHandler *handler = (DirectSignalHandler*) l;          if (handler->removed) {               direct_list_remove( &handlers, &handler->link );               D_MAGIC_CLEAR( handler );               D_FREE( handler );               continue;          }          D_LOG( Direct_Signals, FATAL, "    --> %d/n", handler->num );          if (handler->num != num && handler->num != DIRECT_SIGNAL_ANY)               continue;          if (handler->num == DIRECT_SIGNAL_ANY && num == DIRECT_SIGNAL_DUMP_STACK)               continue;          switch (handler->func( num, addr, handler->ctx )) {               case DSHR_OK:                    break;               case DSHR_REMOVE:                    direct_list_remove( &handlers, &handler->link );                    D_MAGIC_CLEAR( handler );                    D_FREE( handler );                    break;               case DSHR_RESUME:                    D_LOG( Direct_Signals, FATAL, "    '-> cured!/n" );                    direct_mutex_unlock( &handlers_lock );                    return;               default:                    D_BUG( "unknown result" );                    break;          }     }

voiddfb_font_destroy( CoreFont *font ){     int i;     D_MAGIC_ASSERT( font, CoreFont );     D_MAGIC_CLEAR( font );     pthread_mutex_lock( &font->lock );     dfb_state_set_destination( &font->state, NULL );     dfb_state_set_source( &font->state, NULL );     dfb_state_destroy( &font->state );     direct_tree_destroy( font->glyph_infos );     if (font->surfaces) {          for (i = 0; i < font->rows; i++)               dfb_surface_unref( font->surfaces[i] );          D_FREE( font->surfaces );     }     pthread_mutex_unlock( &font->lock );     pthread_mutex_destroy( &font->lock );     D_FREE( font );}

static DFBResultfbdevDeallocateBuffer( CoreSurfacePool       *pool,                       void                  *pool_data,                       void                  *pool_local,                       CoreSurfaceBuffer     *buffer,                       CoreSurfaceAllocation *allocation,                       void                  *alloc_data ){     FBDevPoolData       *data  = pool_data;     FBDevAllocationData *alloc = alloc_data;     D_DEBUG_AT( FBDev_Surfaces, "%s( %p )/n", __FUNCTION__, buffer );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_MAGIC_ASSERT( data, FBDevPoolData );     D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );     D_MAGIC_ASSERT( alloc, FBDevAllocationData );     if (alloc->chunk)          dfb_surfacemanager_deallocate( data->manager, alloc->chunk );     D_MAGIC_CLEAR( alloc );     return DFB_OK;}

static DFBResultstmfbdevDeallocateBuffer (CoreSurfacePool       *pool,                          void                  *pool_data,                          void                  *pool_local,                          CoreSurfaceBuffer     *buffer,                          CoreSurfaceAllocation *allocation,                          void                  *alloc_data){  STMfbdevPoolData            * const data  = pool_data;  const STMfbdevPoolLocalData * const local = pool_local;  STMfbdevPoolAllocationData  * const alloc = alloc_data;  D_DEBUG_AT (STMfbdev_Surfaces, "%s (%p)/n", __FUNCTION__, buffer);  D_MAGIC_ASSERT (pool, CoreSurfacePool);  D_MAGIC_ASSERT (data, STMfbdevPoolData);  D_MAGIC_ASSERT (local, STMfbdevPoolLocalData);  D_MAGIC_ASSERT (buffer, CoreSurfaceBuffer);  D_MAGIC_ASSERT (allocation, CoreSurfaceAllocation);  D_MAGIC_ASSERT (alloc, STMfbdevPoolAllocationData);  (void) local;  D_ASSERT (alloc->chunk != NULL);  dfb_surfacemanager_deallocate (data->manager, alloc->chunk);  D_MAGIC_CLEAR (alloc);  return DFB_OK;}

static DFBResultmesaDeallocateBuffer( CoreSurfacePool       *pool,                      void                  *pool_data,                      void                  *pool_local,                      CoreSurfaceBuffer     *buffer,                      CoreSurfaceAllocation *allocation,                      void                  *alloc_data ){     MesaPoolData       *data  = pool_data;     MesaAllocationData *alloc = alloc_data;     MesaPoolLocalData  *local = pool_local;     (void)data;     D_DEBUG_AT( Mesa_Surfaces, "%s( %p )/n", __FUNCTION__, buffer );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_MAGIC_ASSERT( data, MesaPoolData );     D_MAGIC_ASSERT( alloc, MesaAllocationData );     drmModeRmFB( local->mesa->fd,  alloc->fb_id );     eglDestroyImageKHR( local->mesa->dpy, alloc->image );     gbm_bo_destroy( alloc->bo );     D_MAGIC_CLEAR( alloc );     return DFB_OK;}

static DFBResultwm_remove_window( CoreWindowStack *stack,                  void            *wm_data,                  void            *stack_data,                  CoreWindow      *window,                  void            *window_data ){     WindowData *data = window_data;     D_ASSERT( stack != NULL );     D_ASSERT( wm_data != NULL );     D_ASSERT( stack_data != NULL );     D_ASSERT( window != NULL );     D_ASSERT( window_data != NULL );     D_MAGIC_ASSERT( data, WindowData );//     D_ASSUME( data->window == NULL );     if (data->window)          unique_window_detach_global( data->window, &data->window_reaction );     D_MAGIC_CLEAR( data );     return DFB_OK;}

static void palette_destructor( FusionObject *object, bool zombie, void *ctx ){     CorePaletteNotification  notification;     CorePalette             *palette = (CorePalette*) object;     D_MAGIC_ASSERT( palette, CorePalette );     D_DEBUG_AT( Core_Palette, "destroying %p (%d)%s/n", palette,                 palette->num_entries, zombie ? " (ZOMBIE)" : "");     D_ASSERT( palette->entries != NULL );     D_ASSERT( palette->entries_yuv != NULL );     notification.flags   = CPNF_DESTROY;     notification.palette = palette;     dfb_palette_dispatch( palette, &notification, dfb_palette_globals );     if (palette->hash_attached) {          dfb_colorhash_invalidate( NULL, palette );          dfb_colorhash_detach( NULL, palette );     }     SHFREE( palette->shmpool, palette->entries_yuv );     SHFREE( palette->shmpool, palette->entries );     D_MAGIC_CLEAR( palette );     fusion_object_destroy( object );}

static voidsurface_client_destructor( FusionObject *object, bool zombie, void *ctx ){     CoreSurfaceClient *client = (CoreSurfaceClient*) object;     CoreSurface       *surface;     int                index;     D_MAGIC_ASSERT( client, CoreSurfaceClient );     surface = client->surface;     CORE_SURFACE_ASSERT( surface );     D_DEBUG_AT( Core_SurfClient, "destroying %p (%dx%d%s)/n", client,                 surface->config.size.w, surface->config.size.h, zombie ? " ZOMBIE" : "");     CoreSurfaceClient_Deinit_Dispatch( &client->call );     dfb_surface_lock( surface );     index = fusion_vector_index_of( &surface->clients, client );     D_ASSERT( index >= 0 );     fusion_vector_remove( &surface->clients, index );     dfb_surface_check_acks( surface );     dfb_surface_unlock( surface );     dfb_surface_unlink( &client->surface );     D_MAGIC_CLEAR( client );     fusion_object_destroy( object );}

static voidleave_pool( FusionSHM           *shm,            FusionSHMPool       *pool,            FusionSHMPoolShared *shared ){     FusionWorld *world;     D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )/n", __FUNCTION__, shm, pool, shared );     D_MAGIC_ASSERT( shm, FusionSHM );     D_MAGIC_ASSERT( pool, FusionSHMPool );     D_MAGIC_ASSERT( shared, FusionSHMPoolShared );     world = shm->world;     D_MAGIC_ASSERT( world, FusionWorld );     if (munmap( shared->addr_base, shared->max_size ))          D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!/n", pool->filename );     pool->attached = false;     D_FREE( pool->filename );     D_MAGIC_CLEAR( pool );}

VoodooInstance::~VoodooInstance(){     D_DEBUG_AT( Voodoo_Instance, "VoodooInstance::%s( %p )/n", __func__, this );     D_MAGIC_ASSERT( this, VoodooInstance );     D_MAGIC_CLEAR( this );}

voidone_core_wq_deinit( OneCore      *core,                    OneWaitQueue *queue ){     D_MAGIC_ASSERT( core, OneCore );     D_MAGIC_ASSERT( queue, OneWaitQueue );     D_MAGIC_CLEAR( queue );}

static DFBResultmesaDestroyPool( CoreSurfacePool *pool,                 void            *pool_data,                 void            *pool_local ){     MesaPoolData      *data  = pool_data;     MesaPoolLocalData *local = pool_local;     D_DEBUG_AT( Mesa_Surfaces, "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_MAGIC_ASSERT( data, MesaPoolData );     D_MAGIC_ASSERT( local, MesaPoolLocalData );     D_MAGIC_CLEAR( data );     D_MAGIC_CLEAR( local );     return DFB_OK;}

VoodooConnection::~VoodooConnection(){     D_DEBUG_AT( Voodoo_Connection, "VoodooConnection::%s( %p )/n", __func__, this );     D_MAGIC_ASSERT( this, VoodooConnection );     link->Close( link );     D_MAGIC_CLEAR( this );}

DFBResult x11ImageInit( DFBX11                *x11,                        x11Image              *image,                        int                    width,                        int                    height,                        DFBSurfacePixelFormat  format ){     int           ret;     Visual       *visual;     DFBX11Shared *shared = x11->shared;     if (!x11->use_shm)          return DFB_UNSUPPORTED;     /* Lookup visual. */     visual = x11->visuals[DFB_PIXELFORMAT_INDEX(format)];     if (!visual)          return DFB_UNSUPPORTED;     /* For probing. */     if (!image)          return DFB_OK;     image->width  = width;     image->height = height;     image->format = format;     image->depth  = DFB_COLOR_BITS_PER_PIXEL( format );     D_MAGIC_SET( image, x11Image );     if (fusion_call_execute( &shared->call, FCEF_NONE, X11_IMAGE_INIT, image, &ret )) {          D_MAGIC_CLEAR( image );          return DFB_FUSION;     }     if (ret) {          D_DERROR( ret, "X11/Image: X11_IMAGE_INIT call failed!/n" );          D_MAGIC_CLEAR( image );          return ret;     }     return DFB_OK;}

static voidshutdown_pool( FusionSHM           *shm,               FusionSHMPool       *pool,               FusionSHMPoolShared *shared ){     FusionWorld *world;     D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )/n", __FUNCTION__, shm, pool, shared );     D_MAGIC_ASSERT( shm, FusionSHM );     D_MAGIC_ASSERT( pool, FusionSHMPool );     D_MAGIC_ASSERT( shared, FusionSHMPoolShared );     world = shm->world;     D_MAGIC_ASSERT( world, FusionWorld );     SHFREE( shared, shared->name );     fusion_dbg_print_memleaks( shared );     if (munmap( shared->addr_base, shared->max_size ))          D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!/n", pool->filename );     if (pool->fd != -1 && close( pool->fd ))          D_PERROR( "Fusion/SHM: Could not close shared memory file '%s'!/n", pool->filename );     if (unlink( pool->filename ))          D_PERROR( "Fusion/SHM: Could not unlink shared memory file '%s'!/n", pool->filename );     shared->active = false;     pool->attached = false;     D_FREE( pool->filename );     D_MAGIC_CLEAR( pool );     fusion_skirmish_destroy( &shared->lock );     D_MAGIC_CLEAR( shared );}

voidCoreGraphicsStateClient_Deinit( CoreGraphicsStateClient *client ){     D_DEBUG_AT( Core_GraphicsStateClient, "%s( client %p )/n", __FUNCTION__, client );     D_MAGIC_ASSERT( client, CoreGraphicsStateClient );     dfb_graphics_state_unref( client->gfx_state );     D_MAGIC_CLEAR( client );}

static DFBResultdfb_colorhash_core_shutdown( DFBColorHashCore *data,                             bool              emergency ){     DFBColorHashCoreShared *shared;     D_DEBUG_AT( Core_ColorHash, "dfb_colorhash_core_shutdown( %p, %semergency )/n", data, emergency ? "" : "no " );     D_MAGIC_ASSERT( data, DFBColorHashCore );     D_MAGIC_ASSERT( data->shared, DFBColorHashCoreShared );     shared = data->shared;     fusion_skirmish_destroy( &shared->hash_lock );     D_MAGIC_CLEAR( data );     D_MAGIC_CLEAR( shared );     return DFB_OK;}

static DFBResultfbdevDestroyPool( CoreSurfacePool *pool,                  void            *pool_data,                  void            *pool_local ){     FBDevPoolData      *data  = pool_data;     FBDevPoolLocalData *local = pool_local;     D_DEBUG_AT( FBDev_Surfaces, "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_MAGIC_ASSERT( data, FBDevPoolData );     D_MAGIC_ASSERT( local, FBDevPoolLocalData );     dfb_surfacemanager_destroy( data->manager );     D_MAGIC_CLEAR( data );     D_MAGIC_CLEAR( local );     return DFB_OK;}

voiddirect_map_destroy( DirectMap *map ){     D_DEBUG_AT( Direct_Map, "%s()/n", __func__ );     DIRECT_MAP_ASSERT( map );     D_MAGIC_CLEAR( map );     D_FREE( map->entries );     D_FREE( map );}

voidone_core_exit( OneCore *core ){     ONE_DEBUG( "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( core, OneCore );     D_MAGIC_CLEAR( core );     kfree( core );}

voidOneTarget_Destroy( OneTarget *target ){     ONE_DEBUG( "%s( %p )/n", __FUNCTION__, target );     D_MAGIC_ASSERT( target, OneTarget );     D_MAGIC_CLEAR( target );     one_core_free( one_core, target );}

static intdfb_core_arena_initialize( FusionArena *arena,                           void        *ctx ){     DFBResult            ret;     CoreDFB             *core = ctx;     CoreDFBShared       *shared;     FusionSHMPoolShared *pool;     D_MAGIC_ASSERT( core, CoreDFB );     D_DEBUG_AT( DirectFB_Core, "Initializing.../n" );     /* Create the shared memory pool first! */     ret = fusion_shm_pool_create( core->world, "DirectFB Main Pool", 0x400000,                                   fusion_config->debugshm, &pool );     if (ret)          return ret;     /* Allocate shared structure in the new pool. */     shared = SHCALLOC( pool, 1, sizeof(CoreDFBShared) );     if (!shared) {          fusion_shm_pool_destroy( core->world, pool );          return D_OOSHM();     }     core->shared = shared;     core->master = true;     shared->shmpool = pool;     D_MAGIC_SET( shared, CoreDFBShared );     /* Initialize. */     ret = dfb_core_initialize( core );     if (ret) {          D_MAGIC_CLEAR( shared );          SHFREE( pool, shared );          fusion_shm_pool_destroy( core->world, pool );          return ret;     }     fusion_skirmish_init( &shared->lock, "DirectFB Core", core->world );     CoreDFB_Init_Dispatch( core, core, &shared->call );     fusion_call_add_permissions( &shared->call, 0, FUSION_CALL_PERMIT_EXECUTE );     /* Register shared data. */     fusion_arena_add_shared_field( arena, "Core/Shared", shared );     return DFB_OK;}

DirectResultfusion_shm_pool_destroy( FusionWorld         *world,                         FusionSHMPoolShared *pool ){     D_MAGIC_ASSERT( pool, FusionSHMPoolShared );     D_MAGIC_CLEAR( pool );     D_FREE( pool );     return DR_OK;}

static voidsurface_destructor( FusionObject *object, bool zombie, void *ctx ){     int          i;     CoreSurface *surface = (CoreSurface*) object;     D_MAGIC_ASSERT( surface, CoreSurface );     D_DEBUG_AT( Core_Surface, "destroying %p (%dx%d%s)/n", surface,                 surface->config.size.w, surface->config.size.h, zombie ? " ZOMBIE" : "");     Core_Resource_RemoveSurface( surface );     CoreSurface_Deinit_Dispatch( &surface->call );     dfb_surface_lock( surface );     surface->state |= CSSF_DESTROYED;     /* announce surface destruction */     dfb_surface_notify( surface, CSNF_DESTROY );     /* unlink palette */     if (surface->palette) {          dfb_palette_detach_global( surface->palette, &surface->palette_reaction );          dfb_palette_unlink( &surface->palette );     }     /* destroy buffers */     for (i=0; i<MAX_SURFACE_BUFFERS; i++) {          if (surface->buffers[i])               dfb_surface_buffer_decouple( surface->buffers[i] );     }     dfb_system_surface_data_destroy( surface, surface->data );     /* release the system driver specific surface data */     if (surface->data) {          SHFREE( surface->shmpool, surface->data );          surface->data = NULL;     }     direct_serial_deinit( &surface->serial );     dfb_surface_unlock( surface );     fusion_skirmish_destroy( &surface->lock );     D_MAGIC_CLEAR( surface );     fusion_object_destroy( object );}

static voidcall_tls_destroy( void *arg ){     CallTLS *call_tls = arg;     D_MAGIC_ASSERT( call_tls, CallTLS );     fusion_world_flush_calls( call_tls->world, 0 );     D_MAGIC_CLEAR( call_tls );     D_FREE( call_tls );}

static DFBResultdfb_clipboard_core_leave( DFBClipboardCore *data,                          bool              emergency ){     D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_leave( %p, %semergency )/n", data, emergency ? "" : "no " );     D_MAGIC_ASSERT( data, DFBClipboardCore );     D_MAGIC_ASSERT( data->shared, DFBClipboardCoreShared );     D_MAGIC_CLEAR( data );     return DFB_OK;}