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

static intPacket_Write( Packet     *packet,              int         type,              int         msg_id,              int         channel,              const void *msg_data,              int         msg_size,              const void *extra_data,              int         extra_size,              bool        from_user ){     size_t             total   = sizeof(FusionReadMessage) + msg_size + extra_size;     size_t             aligned = (total + 3) & ~3;     FusionReadMessage *header  = (FusionReadMessage *)( packet->buf + packet->size );     FUSION_DEBUG( "%s( %p, msg_id %d, channel %d, size %d, extra %d, total %zu )/n",                   __FUNCTION__, packet, msg_id, channel, msg_size, extra_size, total );     D_MAGIC_ASSERT( packet, Packet );     FUSION_ASSERT( packet->size + aligned <= FUSION_MAX_PACKET_SIZE );     header->msg_type    = type;     header->msg_id      = msg_id;     header->msg_channel = channel;     header->msg_size    = msg_size + extra_size;     if (from_user) {          if (copy_from_user( header + 1, msg_data, msg_size ))               return -EFAULT;     }     else          memcpy( header + 1, msg_data, msg_size );     if (extra_data && extra_size) {          if (copy_from_user( (char*)(header + 1) + msg_size, extra_data, extra_size ))               return -EFAULT;     }     while (total < aligned)          packet->buf[packet->size + total++] = 0;     packet->size += aligned;     return 0;}

static DFBResultsharedDeallocateBuffer( CoreSurfacePool       *pool,                        void                  *pool_data,                        void                  *pool_local,                        CoreSurfaceBuffer     *buffer,                        CoreSurfaceAllocation *allocation,                        void                  *alloc_data ){    SharedPoolData       *data  = pool_data;    SharedAllocationData *alloc = alloc_data;    D_MAGIC_ASSERT( pool, CoreSurfacePool );    SHFREE( data->shmpool, alloc->addr );    return DFB_OK;}

static DFBResultx11InitPool( CoreDFB                    *core,             CoreSurfacePool            *pool,             void                       *pool_data,             void                       *pool_local,             void                       *system_data,             CoreSurfacePoolDescription *ret_desc ){     DFBResult         ret;     x11PoolLocalData *local = pool_local;     DFBX11           *x11   = system_data;     D_DEBUG_AT( X11_Surfaces, "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_ASSERT( ret_desc != NULL );     local->x11 = x11;     ret_desc->caps     = CSPCAPS_NONE;     ret_desc->types    = CSTF_LAYER | CSTF_WINDOW | CSTF_SHARED | CSTF_EXTERNAL;     ret_desc->priority = CSPP_ULTIMATE;     /* For showing our X11 window */     ret_desc->access[CSAID_LAYER0] = CSAF_READ;     ret_desc->access[CSAID_LAYER1] = CSAF_READ;     ret_desc->access[CSAID_LAYER2] = CSAF_READ;     snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "X11 Windows" );     ret = direct_hash_create( 7, &local->hash );     if (ret) {          D_DERROR( ret, "X11/Surfaces: Could not create local hash table!/n" );          return ret;     }     pthread_mutex_init( &local->lock, NULL );     int event_base_return, error_base_return;     XLockDisplay( x11->display );     XCompositeQueryExtension( x11->display, &event_base_return, &error_base_return );     x11->Sync( x11 );     XUnlockDisplay( x11->display );     return DFB_OK;}

voidVoodooInstance::Release(){     D_DEBUG_AT( Voodoo_Instance, "VoodooInstance::%s( %p )/n", __func__, this );     D_MAGIC_ASSERT( this, VoodooInstance );     D_ASSERT( refs > 0 );     if (!--refs) {          D_DEBUG_AT( Voodoo_Instance, "  -> zero refs, deleting instance.../n" );#ifndef WIN32  //FIXME: why does delete this crash with MSVC?          delete this;#endif     }}

DFBResultunique_decoration_notify( UniqueDecoration                  *decoration,                          UniqueDecorationNotificationFlags  flags ){     UniqueDecorationNotification notification;     D_MAGIC_ASSERT( decoration, UniqueDecoration );     D_ASSERT( flags != UDNF_NONE );     D_ASSERT( ! (flags & ~UDNF_ALL) );     notification.flags      = flags;     notification.decoration = decoration;     return unique_decoration_dispatch( decoration, &notification, unique_decoration_globals );}

static DFBResultdfb_clipboard_core_join( CoreDFB                *core,                         DFBClipboardCore       *data,                         DFBClipboardCoreShared *shared ){     D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_join( %p, %p, %p )/n", core, data, shared );     D_ASSERT( data != NULL );     D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );     data->core   = core;     data->shared = shared;     D_MAGIC_SET( data, DFBClipboardCore );     return DFB_OK;}

DFBResultdfb_surface_set_field( CoreSurface *surface,                       int          field ){     D_MAGIC_ASSERT( surface, CoreSurface );     if (fusion_skirmish_prevail( &surface->lock ))          return DFB_FUSION;     surface->field = field;     dfb_surface_notify( surface, CSNF_FIELD );     fusion_skirmish_dismiss( &surface->lock );     return DFB_OK;}

voidfusion_vector_destroy( FusionVector *vector ){     D_MAGIC_ASSERT( vector, FusionVector );     D_ASSERT( vector->count == 0 || vector->elements != NULL );     if (vector->elements) {          if (vector->pool)               SHFREE( vector->pool, vector->elements );          else               D_FREE( vector->elements );          vector->elements = NULL;     }     D_MAGIC_CLEAR( vector );}

static DFBResultx11LeavePool( CoreSurfacePool *pool,              void            *pool_data,              void            *pool_local ){     x11PoolLocalData *local = pool_local;     D_DEBUG_AT( X11_Surfaces, "%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     pthread_mutex_destroy( &local->lock );     direct_hash_destroy( local->hash );     return DFB_OK;}

DFBResultdfb_surface_unlock_buffer( CoreSurface           *surface,                           CoreSurfaceBufferLock *lock ){     DFBResult ret;     D_MAGIC_ASSERT( surface, CoreSurface );     if (fusion_skirmish_prevail( &surface->lock ))          return DFB_FUSION;     ret = dfb_surface_buffer_unlock( lock );     fusion_skirmish_dismiss( &surface->lock );     return ret;}

DFBResultdfb_state_set_source_2( CardState   *state,                        CoreSurface *source,                        u32          flip_count ){     D_MAGIC_ASSERT( state, CardState );     dfb_state_lock( state );     if (state->source != source || state->source_flip_count != flip_count || !state->source_flip_count_used) {          bool ref = true;//!fusion_config->secure_fusion || dfb_core_is_master( core_dfb );          if (source && ref && dfb_surface_ref( source )) {               D_WARN( "could not ref() source" );               dfb_state_unlock( state );               return DFB_DEAD;          }          if (state->source) {               D_ASSERT( D_FLAGS_IS_SET( state->flags, CSF_SOURCE ) );               if (ref)                    dfb_surface_unref( state->source );          }          state->source    = source;          state->modified |= SMF_SOURCE;          state->source_flip_count      = flip_count;          state->source_flip_count_used = true;          if (source) {               direct_serial_copy( &state->src_serial, &source->serial );               D_FLAGS_SET( state->flags, CSF_SOURCE );          }          else               D_FLAGS_CLEAR( state->flags, CSF_SOURCE );     }     dfb_state_unlock( state );     return DFB_OK;}

DirectResultvoodoo_manager_destroy( VoodooManager *manager ){     D_MAGIC_ASSERT( manager, VoodooManager );     D_DEBUG( "Voodoo/Manager: Destroying manager at %p!/n", manager );     if (!manager->quit)          voodoo_manager_quit( manager );     /* Wait for manager threads exiting. */     direct_thread_join( manager->input.thread );     direct_thread_destroy( manager->input.thread );     direct_thread_join( manager->dispatcher );     direct_thread_destroy( manager->dispatcher );     direct_thread_join( manager->output.thread );     direct_thread_destroy( manager->output.thread );     /* Destroy conditions. */     pthread_cond_destroy( &manager->input.wait );     pthread_cond_destroy( &manager->response.wait );     pthread_cond_destroy( &manager->output.wait );     /* Destroy locks. */     pthread_mutex_destroy( &manager->instances.lock );     pthread_mutex_destroy( &manager->input.lock );     pthread_mutex_destroy( &manager->response.lock );     pthread_mutex_destroy( &manager->output.lock );     /* Release all remaining interfaces. */     direct_hash_iterate( manager->instances.local, instance_iterator, (void*) false );     direct_hash_iterate( manager->instances.local, instance_iterator, (void*) true );     direct_hash_destroy( manager->instances.local );     direct_hash_destroy( manager->instances.remote );     D_MAGIC_CLEAR( manager );     /* Deallocate manager structure. */     D_FREE( manager );     return DR_OK;}

voiddirect_thread_cancel( DirectThread *thread ){     D_MAGIC_ASSERT( thread, DirectThread );     D_ASSERT( thread->handle.thread != -1 );     D_ASSERT( !pthread_equal( thread->handle.thread, pthread_self() ) );     D_ASSUME( !thread->canceled );     D_DEBUG_AT( Direct_Thread, "%s( %p, '%s' %d )/n", __FUNCTION__, thread->main, thread->name, thread->tid );     thread->canceled = true;#ifndef DIRECT_BUILD_NO_PTHREAD_CANCEL     pthread_cancel( thread->handle.thread );#else     D_UNIMPLEMENTED();#endif}

static DFBResultwm_request_focus( CoreWindow *window,                  void       *wm_data,                  void       *window_data ){     WindowData *data = window_data;     D_ASSERT( window != NULL );     D_ASSERT( wm_data != NULL );     D_ASSERT( window_data != NULL );     D_MAGIC_ASSERT( data, WindowData );     if (!data->window)          return DFB_DESTROYED;     return unique_window_request_focus( data->window );}

static DFBResultwm_flush_keys( CoreWindowStack *stack,               void            *wm_data,               void            *stack_data ){     StackData *data = stack_data;     D_ASSERT( stack != NULL );     D_ASSERT( wm_data != NULL );     D_ASSERT( stack_data != NULL );     D_MAGIC_ASSERT( data, StackData );     if (!data->context)          return DFB_DESTROYED;     return unique_context_flush_keys( data->context );}

voidVoodooConnectionLink::PutPacket( VoodooPacket *packet, bool flush ){     D_DEBUG_AT( Voodoo_Connection, "VoodooConnectionLink::%s( %p, %sflush )/n", __func__, this, flush ? "" : "NO " );     D_MAGIC_ASSERT( this, VoodooConnection );     Packets *packets = (Packets*) direct_tls_get( output.tls );     D_ASSERT( packets != NULL );     D_ASSERT( packet == packets->active );     if (flush) {          Flush( packet );          packets->active = NULL;     }}

voiddirect_thread_notify( DirectThread *thread ){     D_MAGIC_ASSERT( thread, DirectThread );     D_ASSERT( thread->thread != -1 );     D_ASSUME( !thread->canceled );     D_DEBUG_AT( Direct_Thread, "%s( %p, '%s' %d )/n", __FUNCTION__, thread->main, thread->name, thread->tid );     pthread_mutex_lock( &thread->lock );     thread->counter++;     pthread_mutex_unlock( &thread->lock );     pthread_cond_broadcast( &thread->cond );}

DirectResultfusion_property_init (FusionProperty *property, const FusionWorld *world){     D_ASSERT( property != NULL );     D_MAGIC_ASSERT( world, FusionWorld );     /* Set state to available. */     property->multi.builtin.state = FUSION_PROPERTY_AVAILABLE;     property->multi.builtin.owner = 0;     property->multi.builtin.requested = false;     property->multi.builtin.destroyed = false;     /* Keep back pointer to shared world data. */     property->multi.shared = world->shared;     return DR_OK;}

DirectResultfusion_vector_remove( FusionVector *vector,                      int           index ){     D_MAGIC_ASSERT( vector, FusionVector );     D_ASSERT( index >= 0 );     D_ASSERT( index < vector->count );     /* Move elements after this element one down. */     memmove( &vector->elements[ index ],              &vector->elements[ index + 1 ],              (vector->count - index - 1) * sizeof(void*) );     /* Decrease the element counter. */     vector->count--;     return DR_OK;}

voidDirectUnregisterInterface( DirectInterfaceFuncs *funcs ){    DirectInterfaceImplementation *impl;    D_DEBUG_AT( Direct_Interface, "%s( %p )/n", __FUNCTION__, funcs );    direct_mutex_lock( &implementations_mutex );    direct_list_foreach (impl, implementations) {        D_MAGIC_ASSERT( impl, DirectInterfaceImplementation );        if (impl->funcs == funcs) {            direct_list_remove( &implementations, &impl->link );            break;        }    }

voiddfb_state_set_matrix( CardState *state,                      const s32 *matrix ){     D_MAGIC_ASSERT( state, CardState );     D_ASSERT( matrix != NULL );     if (memcmp( state->matrix, matrix, sizeof(state->matrix) )) {          direct_memcpy( state->matrix, matrix, sizeof(state->matrix) );                    state->affine_matrix = (matrix[6] == 0x00000 &&                                   matrix[7] == 0x00000 &&                                  matrix[8] == 0x10000);          state->modified |= SMF_MATRIX;     }}

DFBResultIWindow_Real::SetCursorPosition( int x,                                 int y ){     DFBResult ret;     D_DEBUG_AT( Core_Window, "IWindow_Real::%s( %p )/n", __FUNCTION__, obj );     D_MAGIC_ASSERT( obj, CoreWindow );     dfb_windowstack_lock( obj->stack );     ret = dfb_wm_set_cursor_position( obj, x, y );     dfb_windowstack_unlock( obj->stack );     return ret;}

static DFBResultstmfbdevLock (CoreSurfacePool       *pool,              void                  *pool_data,              void                  *pool_local,              CoreSurfaceAllocation *allocation,              void                  *alloc_data,              CoreSurfaceBufferLock *lock){  const STMfbdevPoolData           * const data  = pool_data;  const STMfbdevPoolLocalData      * const local = pool_local;  const STMfbdevPoolAllocationData * const alloc = alloc_data;  const Chunk                      *chunk;  D_DEBUG_AT (STMfbdev_SurfLock, "%s (%p)/n", __FUNCTION__, lock->buffer);  D_MAGIC_ASSERT (pool, CoreSurfacePool);  D_MAGIC_ASSERT (data, STMfbdevPoolData);  D_MAGIC_ASSERT (local, STMfbdevPoolLocalData);  D_MAGIC_ASSERT (allocation, CoreSurfaceAllocation);  D_MAGIC_ASSERT (alloc, STMfbdevPoolAllocationData);  D_MAGIC_ASSERT (lock, CoreSurfaceBufferLock);  D_MAGIC_ASSERT (alloc->chunk, Chunk);  chunk = alloc->chunk;#if D_DEBUG_ENABLED  {  /* heavy performance hit */  char *accessor = _accessor_str (lock->accessor);  char *access   = _access_str (lock->access);  D_DEBUG_AT (STMfbdev_SurfLock, "  -> by %s for %s/n", accessor,  access);  free (access);  free (accessor);  }#endif  lock->pitch  = chunk->pitch;  lock->offset = chunk->offset;  lock->addr   = local->mem + chunk->offset;  lock->phys   = data->physical + chunk->offset;  D_DEBUG_AT (STMfbdev_SurfLock,              "  -> offset 0x%.8lx (%lu), pitch %d, addr %p, phys 0x%.8lx/n",              lock->offset, lock->offset, lock->pitch, lock->addr, lock->phys);  return DFB_OK;}

static intdfb_core_join( CoreDFB *core ){     int i;     D_MAGIC_ASSERT( core, CoreDFB );     for (i=0; i<D_ARRAY_SIZE(core_parts); i++) {          DFBResult ret;          if ((ret = dfb_core_part_join( core, core_parts[i] ))) {               dfb_core_leave( core, true );               return ret;          }     }     return DFB_OK;}

DirectResultdirect_signal_handler_remove( DirectSignalHandler *handler ){     D_MAGIC_ASSERT( handler, DirectSignalHandler );     D_DEBUG_AT( Direct_Signals, "Removing handler %p for signal %d with context %p.../n",                 handler->func, handler->num, handler->ctx );     direct_mutex_lock( &handlers_lock );     direct_list_remove( &handlers, &handler->link );     direct_mutex_unlock( &handlers_lock );     D_MAGIC_CLEAR( handler );     D_FREE( handler );     return DR_OK;}

DirectResultdirect_log_destroy( DirectLog *log ){     D_MAGIC_ASSERT( log, DirectLog );     D_ASSERT( &fallback_log != log );     if (log == default_log)          default_log = NULL;     close( log->fd );     D_MAGIC_CLEAR( log );     D_FREE( log );     return DR_OK;}

static DFBResultfbdevInitPool( CoreDFB                    *core,               CoreSurfacePool            *pool,               void                       *pool_data,               void                       *pool_local,               void                       *system_data,               CoreSurfacePoolDescription *ret_desc ){     DFBResult           ret;     FBDevPoolData      *data  = pool_data;     FBDevPoolLocalData *local = pool_local;     D_DEBUG_AT( FBDev_Surfaces, "%s()/n", __FUNCTION__ );     D_ASSERT( core != NULL );     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_ASSERT( data != NULL );     D_ASSERT( local != NULL );     D_ASSERT( ret_desc != NULL );     ret = dfb_surfacemanager_create( core, dfb_fbdev->shared->fix.smem_len, &data->manager );     if (ret)          return ret;     ret_desc->caps     = CSPCAPS_NONE;     ret_desc->access   = CSAF_CPU_READ | CSAF_CPU_WRITE | CSAF_GPU_READ | CSAF_GPU_WRITE | CSAF_SHARED;     ret_desc->types    = CSTF_LAYER | CSTF_WINDOW | CSTF_CURSOR | CSTF_FONT | CSTF_SHARED | CSTF_EXTERNAL;     ret_desc->priority = CSPP_DEFAULT;     snprintf( ret_desc->name, DFB_SURFACE_POOL_DESC_NAME_LENGTH, "Frame Buffer Memory" );     local->core = core;     D_MAGIC_SET( data, FBDevPoolData );     D_MAGIC_SET( local, FBDevPoolLocalData );     D_ASSERT( dfb_fbdev != NULL );     D_ASSERT( dfb_fbdev->shared != NULL );     dfb_fbdev->shared->manager = data->manager;     return DFB_OK;}

DFBResultICore_Real::CreateImageProvider(                    u32                                        buffer_call,                    u32                                       *ret_call){     DFBResult               ret;     IDirectFBDataBuffer    *buffer;     IDirectFBImageProvider *provider;     ImageProviderDispatch  *dispatch;     D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Real::%s()/n", __FUNCTION__ );     D_MAGIC_ASSERT( obj, CoreDFB );     D_ASSERT( ret_call != NULL );     DIRECT_ALLOCATE_INTERFACE( buffer, IDirectFBDataBuffer );     if (!buffer)          return (DFBResult) D_OOM();     /* Construct data buffer client */     ret = IDirectFBDataBuffer_Client_Construct( buffer, core, buffer_call );     if (ret)          return ret;     /* Create image provider */     ret = buffer->CreateImageProvider( buffer, &provider );     if (ret) {          buffer->Release( buffer );          return ret;     }     /* Create dispatch object */     ret = ImageProviderDispatch_Create( idirectfb_singleton, buffer, provider, &dispatch );     if (ret) {          provider->Release( provider );          buffer->Release( buffer );          return ret;     }     *ret_call = dispatch->call.call_id;     return DFB_OK;}

static intdfb_core_arena_leave( FusionArena *arena,                      void        *ctx,                      bool         emergency){     DFBResult  ret;     CoreDFB   *core = ctx;     D_MAGIC_ASSERT( core, CoreDFB );     D_DEBUG_AT( DirectFB_Core, "Leaving.../n" );     /* Leave. */     ret = dfb_core_leave( core, emergency );     if (ret)          return ret;     return DFB_OK;}

DFBResultx11ImageDestroy( x11Image *image ){    int ret;    D_MAGIC_ASSERT( image, x11Image );    if (fusion_call_execute( &dfb_x11->call, FCEF_NONE, X11_IMAGE_DESTROY, image, &ret ))        return DFB_FUSION;    if (ret) {        D_DERROR( ret, "X11/Image: X11_IMAGE_DESTROY call failed!/n" );        return ret;    }    D_MAGIC_CLEAR( image );    return DFB_OK;}