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

static DFBResultosdUnlock( CoreSurfacePool       *pool,           void                  *pool_data,           void                  *pool_local,           CoreSurfaceAllocation *allocation,           void                  *alloc_data,           CoreSurfaceBufferLock *lock ){     OSDAllocationData *alloc = alloc_data;     D_MAGIC_ASSERT( pool, CoreSurfacePool );     D_MAGIC_ASSERT( allocation, CoreSurfaceAllocation );     D_MAGIC_ASSERT( alloc, OSDAllocationData );     D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock );     D_DEBUG_AT( OSD_SurfLock, "%s( %p )/n", __FUNCTION__, lock->buffer );     (void) alloc;     return DFB_OK;}

DFBResultILayerContext_Real::FindWindowByResourceID(                    u64                                        resource_id,                    CoreWindow                               **ret_window){     DFBResult                       ret;     CoreLayerContext               *context = obj;     CoreWindowStack                *stack;     FindWindowByResourceID_Context  ctx;     D_DEBUG_AT( DirectFB_CoreLayerContext, "ILayerContext_Real::%s()/n", __FUNCTION__ );     D_ASSERT( ret_window != NULL );     stack = context->stack;     D_ASSERT( stack != NULL );     ctx.resource_id = resource_id;     ctx.window      = NULL;     ret = (DFBResult) dfb_layer_context_lock( context );     if (ret)         return ret;     ret = dfb_wm_enum_windows( stack, FindWindowByResourceID_WindowCallback, &ctx );     if (ret == DFB_OK) {          if (ctx.window) {               ret = (DFBResult) dfb_window_ref( ctx.window );               if (ret == DFB_OK)                    *ret_window = ctx.window;          }          else               ret = DFB_IDNOTFOUND;     }     dfb_layer_context_unlock( context );     return ret;}

static DFBResultdriver_init_device(CoreGraphicsDevice *device,                   GraphicsDeviceInfo *device_info,                   void               *driver_data,                   void               *device_data){     const char   *renderer;     DFBResult     status;     D_DEBUG_AT(GLES2__2D, "%s()/n", __FUNCTION__);     // Now that we have a connection and can query GLES.     renderer = (const char*)glGetString(GL_RENDERER);     // Fill device info.     snprintf(device_info->vendor,              DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "%s", "GLES2 Acceleration -");     snprintf(device_info->name,              DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "%s", renderer ?: "Unknown");     // Initialize shader program objects, shared across all EGL contexts.     status = gles2_init_shader_programs((GLES2DeviceData *)device_data);     if (status != DFB_OK) {          D_ERROR("GLES2/Driver: Could not create shader program objects!/n");          return status;     }     /* device limitations */     device_info->limits.surface_byteoffset_alignment = 8;     device_info->limits.surface_bytepitch_alignment  = 8;     device_info->caps.flags    = CCF_CLIPPING | CCF_RENDEROPTS;     device_info->caps.accel    = GLES2_SUPPORTED_DRAWINGFUNCTIONS |                                  GLES2_SUPPORTED_BLITTINGFUNCTIONS;     device_info->caps.drawing  = GLES2_SUPPORTED_DRAWINGFLAGS;     device_info->caps.blitting = GLES2_SUPPORTED_BLITTINGFLAGS;     return DFB_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" : "");     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_destroy( surface->buffers[i] );     }     direct_serial_deinit( &surface->serial );     dfb_surface_unlock( surface );     fusion_skirmish_destroy( &surface->lock );     D_MAGIC_CLEAR( surface );     fusion_object_destroy( object );}

static DFBResultdrmkmsInitLayer( CoreLayer                  *layer,                 void                       *driver_data,                 void                       *layer_data,                 DFBDisplayLayerDescription *description,                 DFBDisplayLayerConfig      *config,                 DFBColorAdjustment         *adjustment ){     DRMKMSData       *drmkms = driver_data;     DRMKMSDataShared *shared = drmkms->shared;     DRMKMSLayerData  *data   = layer_data;     D_DEBUG_AT( DRMKMS_Layer, "%s()/n", __FUNCTION__ );     data->index       = shared->layerplane_index_count++;     data->layer_index = shared->layer_index_count++;     data->level       = 0;     description->type             = DLTF_GRAPHICS;     description->caps             = DLCAPS_SURFACE;     description->surface_caps     = DSCAPS_NONE;     description->surface_accessor = CSAID_LAYER0;     direct_snputs( description->name, "DRMKMS Layer", DFB_DISPLAY_LAYER_DESC_NAME_LENGTH );     config->flags       = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE;     config->width       = dfb_config->mode.width  ?: shared->mode[data->layer_index].hdisplay;     config->height      = dfb_config->mode.height ?: shared->mode[data->layer_index].vdisplay;     config->pixelformat = dfb_config->mode.format ?: DSPF_ARGB;     config->buffermode  = DLBM_FRONTONLY;     direct_mutex_init( &data->lock );     direct_waitqueue_init( &data->wq_event );     return DFB_OK;}

static DirectResultConstruct( void *interface, ... ){     DFBResult             ret  = DFB_INVARG;     ICoreResourceManager *thiz = interface;     CoreDFB              *core;     DIRECT_ALLOCATE_INTERFACE_DATA(thiz, ICoreResourceManager_test)     D_DEBUG_AT( ICoreResourceManager_test, "%s( %p )/n", __FUNCTION__, thiz );     va_list tag;     va_start(tag, interface);     core = va_arg(tag, CoreDFB *);     va_end( tag );     /* Check arguments. */     if (!thiz)          goto error;     /* Initialize interface data. */     data->ref  = 1;     data->core = core;     /* Initialize function pointer table. */     thiz->AddRef       = ICoreResourceManager_test_AddRef;     thiz->Release      = ICoreResourceManager_test_Release;     thiz->CreateClient = ICoreResourceManager_test_CreateClient;     return DFB_OK;error:     DIRECT_DEALLOCATE_INTERFACE(thiz);     return ret;}

static inline voidvalidate_clip( CardState *state,               int        xmax,               int        ymax,               bool       warn ){     D_DEBUG_AT( Core_GfxState, "%s( %p, %d, %d, %d )/n", __FUNCTION__, state, xmax, ymax, warn );     D_MAGIC_ASSERT( state, CardState );     DFB_REGION_ASSERT( &state->clip );     D_ASSERT( xmax >= 0 );     D_ASSERT( ymax >= 0 );     D_ASSERT( state->clip.x1 <= state->clip.x2 );     D_ASSERT( state->clip.y1 <= state->clip.y2 );     if (state->clip.x1 <= xmax &&         state->clip.y1 <= ymax &&         state->clip.x2 <= xmax &&         state->clip.y2 <= ymax)          return;     if (warn)          D_WARN( "Clip %d,%d-%dx%d invalid, adjusting to fit %dx%d",                  DFB_RECTANGLE_VALS_FROM_REGION( &state->clip ), xmax+1, ymax+1 );     if (state->clip.x1 > xmax)          state->clip.x1 = xmax;     if (state->clip.y1 > ymax)          state->clip.y1 = ymax;     if (state->clip.x2 > xmax)          state->clip.x2 = xmax;     if (state->clip.y2 > ymax)          state->clip.y2 = ymax;     state->modified |= SMF_CLIP;}

DFBResultlite_load_cursor_from_desc(LiteCursor  *cursor, DFBSurfaceDescription *dsc){     DFBResult res;     LITE_NULL_PARAMETER_CHECK(cursor);     LITE_NULL_PARAMETER_CHECK(dsc);     D_DEBUG_AT(LiteCursorDomain, "Load cursor from surface descriptor: %p/n", dsc);     res = lite_util_load_image_desc(&cursor->surface, dsc);     if (res != DFB_OK)          return res;     cursor->width = dsc->width;     cursor->height = dsc->height;     cursor->hot_x = 0;     cursor->hot_y = 0;     return res;}

static voidkeyboard_process_event( UniqueDevice        *device,                        void                *data,                        void                *ctx,                        const DFBInputEvent *event ){     UniqueInputEvent  evt;     KeyboardData     *keyboard = data;     (void) keyboard;     D_MAGIC_ASSERT( device, UniqueDevice );     D_MAGIC_ASSERT( keyboard, KeyboardData );     D_ASSERT( event != NULL );     D_DEBUG_AT( UniQuE_Keyboard, "keyboard_process_event( %p, %p, %p, %p ) <- type 0x%08x/n",                 device, data, ctx, event, event->type );     switch (event->type) {          case DIET_KEYPRESS:          case DIET_KEYRELEASE:               evt.type = UIET_KEY;               evt.keyboard.device_id  = event->device_id;               evt.keyboard.press      = (event->type == DIET_KEYPRESS);               evt.keyboard.key_code   = event->key_code;               evt.keyboard.key_id     = event->key_id;               evt.keyboard.key_symbol = event->key_symbol;               evt.keyboard.modifiers  = event->modifiers;               evt.keyboard.locks      = event->locks;               unique_device_dispatch( device, &evt );               break;          default:               break;     }}

void *VoodooDispatcher::DispatchLoop(){     D_DEBUG_AT( Voodoo_Dispatcher, "VoodooDispatcher::%s( %p )/n", __func__, this );     direct_mutex_lock( &lock );     while (!manager->is_quit) {          VoodooPacket *packet;          D_MAGIC_ASSERT( this, VoodooDispatcher );          if (packets) {               packet = (VoodooPacket*) packets;               direct_list_remove( &packets, &packet->link );               manager->connection->WakeUp();          }          else {               direct_waitqueue_wait( &queue, &lock );               continue;          }          direct_mutex_unlock( &lock );          ProcessMessages( (VoodooMessageHeader*) packet->data_start(), packet->size() );          D_FREE( packet );          direct_mutex_lock( &lock );     }     direct_mutex_unlock( &lock );     return NULL;}

/* * Called by davinciSetState() to ensure that the source ARGB modulation is properly set * for execution of blitting functions. */static inline voiddavinci_validate_SOURCE_MULT( DavinciDeviceData *ddev,                              CardState         *state ){     switch (ddev->dst_format) {          case DSPF_ARGB:               if (state->blittingflags & DSBLIT_COLORIZE)                    ddev->source_mult = 0xff000000 | ddev->color_argb;               else                    ddev->source_mult = 0xffffffff;               break;          default:               D_BUG( "unexpected format %s", dfb_pixelformat_name(ddev->dst_format) );               return;     }     D_DEBUG_AT( Davinci_2D, "  => SOURCE_MULT: 0x%08lx/n", ddev->source_mult );     /* Set the flag. */     DAVINCI_VALIDATE( SOURCE_MULT );}

static DFBResultIDirectFBDisplayLayer_GetLevel( IDirectFBDisplayLayer *thiz,                                int                   *level ){     DFBResult ret;     int       lvl;     D_DEBUG_AT( Layer, "%s( %p )/n", __FUNCTION__, thiz );     DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)     if (!level)          return DFB_INVARG;     ret = dfb_layer_get_level( data->layer, &lvl );     if (ret)          return ret;     *level = lvl;     return DFB_OK;}

static DFBResultIDirectFBDisplayLayer_SetDstColorKey( IDirectFBDisplayLayer *thiz,                                      u8                     r,                                      u8                     g,                                      u8                     b ){     DFBColorKey key;     D_DEBUG_AT( Layer, "%s( %p )/n", __FUNCTION__, thiz );     DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)     if (data->level == DLSCL_SHARED)          return DFB_ACCESSDENIED;     key.r     = r;     key.g     = g;     key.b     = b;     key.index = -1;     return CoreLayerContext_SetDstColorKey( data->context, &key );}

static DFBResultIDirectFBWindow_RequestFocus( IDirectFBWindow *thiz ){     CoreWindow *window;     DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)     D_DEBUG_AT( IDirectFB_Window, "%s()/n", __FUNCTION__ );     if (data->destroyed)          return DFB_DESTROYED;     window = data->window;     if (window->config.options & DWOP_GHOST)          return DFB_UNSUPPORTED;     if (!window->config.opacity && !(window->caps & DWCAPS_INPUTONLY))          return DFB_UNSUPPORTED;     return dfb_window_request_focus( window );}

static DFBResultIDirectFBWindow_Bind( IDirectFBWindow *thiz,                      IDirectFBWindow *source,                      int              x,                      int              y ){     IDirectFBWindow_data *source_data;      DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)     D_DEBUG_AT( IDirectFB_Window, "%s()/n", __FUNCTION__ );     if (data->destroyed)          return DFB_DESTROYED;     DIRECT_INTERFACE_GET_DATA_FROM(source, source_data, IDirectFBWindow);     if (source_data->destroyed)          return DFB_DESTROYED;     return dfb_window_bind( data->window, source_data->window, x, y );}

DFBResultCoreSlaveDispatch__Dispatch( CoreDFB *obj,                                FusionID      caller,                                int           method,                                void         *ptr,                                unsigned int  length,                                void         *ret_ptr,                                unsigned int  ret_size,                                unsigned int *ret_length ){    DFBResult ret;    D_DEBUG_AT( DirectFB_CoreSlave, "CoreSlaveDispatch::%s( %p )/n", __FUNCTION__, obj );    Core_PushIdentity( caller );    ret = __CoreSlaveDispatch__Dispatch( obj, caller, method, ptr, length, ret_ptr, ret_size, ret_length );    Core_PopIdentity();    return ret;}

static DFBResultprimaryInitOutput( CoreScreen                   *screen,                   void                         *driver_data,                   void                         *screen_data,                   int                           output,                   DFBScreenOutputDescription   *description,                   DFBScreenOutputConfig        *config ){     DFBX11       *x11    = driver_data;     DFBX11Shared *shared = x11->shared;     (void) shared;     D_DEBUG_AT( X11_Layer, "%s()/n", __FUNCTION__ );     description->caps = DSOCAPS_RESOLUTION;     config->flags |= DSOCONF_RESOLUTION;     config->resolution = DSOR_UNKNOWN;     return DFB_OK;}

static DFBResultICoreResourceManager_test_CreateClient( ICoreResourceManager  *thiz,                                        FusionID               identity,                                        ICoreResourceClient  **ret_client ){     DFBResult            ret;     ICoreResourceClient *client;     DIRECT_INTERFACE_GET_DATA(ICoreResourceManager_test)     D_DEBUG_AT( ICoreResourceManager_test, "%s( %p )/n", __FUNCTION__, thiz );     DIRECT_ALLOCATE_INTERFACE( client, ICoreResourceClient );     ret = ICoreResourceClient_test_Construct( client, thiz, identity );     if (ret)          return ret;     *ret_client = client;     return DFB_OK;}

VoodooConnectionLink::~VoodooConnectionLink(){     D_DEBUG_AT( Voodoo_Connection, "VoodooConnectionLink::%s( %p )/n", __func__, this );     D_MAGIC_ASSERT( this, VoodooConnection );     /* Acquire locks and wake up waiters. */     direct_mutex_lock( &output.lock );     direct_waitqueue_broadcast( &output.wait );     direct_mutex_unlock( &output.lock );     /* Destroy conditions. */     direct_waitqueue_deinit( &output.wait );     /* Destroy locks. */     direct_mutex_deinit( &output.lock );     /* Deallocate buffers. */     D_FREE( input.buffer );     direct_tls_unregister( &output.tls );}

DirectResultfusion_shm_pool_detach( FusionSHM           *shm,                        FusionSHMPoolShared *pool ){     DirectResult     ret;     FusionSHMShared *shared;     D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p )/n", __FUNCTION__, shm, pool );     D_MAGIC_ASSERT( shm, FusionSHM );     D_MAGIC_ASSERT( pool, FusionSHMPoolShared );     shared = shm->shared;     D_MAGIC_ASSERT( shared, FusionSHMShared );     D_ASSERT( shared == pool->shm );     ret = fusion_skirmish_prevail( &pool->lock );     if (ret) {          fusion_skirmish_dismiss( &shared->lock );          return ret;     }     D_ASSERT( pool->active );     D_ASSERT( pool->index >= 0 );     D_ASSERT( pool->index < FUSION_SHM_MAX_POOLS );     D_ASSERT( pool->pool_id == shm->pools[pool->index].pool_id );     D_ASSERT( pool == &shared->pools[pool->index] );     D_ASSERT( shm->pools[pool->index].attached );     D_MAGIC_ASSERT( &shm->pools[pool->index], FusionSHMPool );     leave_pool( shm, &shm->pools[pool->index], pool );     fusion_skirmish_dismiss( &pool->lock );     return DR_OK;}

static DFBResultIDirectFBWindow_SetStackingClass( IDirectFBWindow        *thiz,                                  DFBWindowStackingClass  stacking_class ){     DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)     D_DEBUG_AT( IDirectFB_Window, "%s()/n", __FUNCTION__ );     if (data->destroyed)          return DFB_DESTROYED;     switch (stacking_class) {          case DWSC_MIDDLE:          case DWSC_UPPER:          case DWSC_LOWER:               break;          default:               return DFB_INVARG;     }     return dfb_window_change_stacking( data->window, stacking_class );}

DirectResultcoma_thread_init( ComaThread *thread,                  Coma       *coma ){     FusionWorld *world;     D_ASSERT( thread != NULL );     D_ASSERT( coma != NULL );     D_DEBUG_AT( Coma_Thread, "%s( %p, %p )/n", __FUNCTION__, thread, coma );     world = coma_world( coma );     thread->shmpool = coma_shmpool( coma );     /* Remember creator. */     thread->fusion_id = fusion_id( world );     D_MAGIC_SET( thread, ComaThread );     return DR_OK;}

/* * End thread, close device and free private data. */static voiddriver_close_device( void *driver_data ){     X11InputData *data = driver_data;     D_DEBUG_AT( X11_Input, "%s()/n", __FUNCTION__ );     /* stop input thread */     data->stop = true;     /* it is possible that this "close" function is called from the same      * thread that the input device is actually running on.      * This happens when you e.g. click the close box with your mouse.      * As a fix, we check if we are this thread. */     if (data->thread != direct_thread_self()) {          direct_thread_join( data->thread );          direct_thread_destroy( data->thread );     }     /* free private data */     D_FREE ( data );}

static DFBResultIDirectFBWindow_SetDstGeometry( IDirectFBWindow         *thiz,                                const DFBWindowGeometry *geometry ){     DFBResult        ret;     CoreWindowConfig config;     DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)     D_DEBUG_AT( IDirectFB_Window, "%s()/n", __FUNCTION__ );     ret = CheckGeometry( geometry );     if (ret)          return ret;     if (data->destroyed)          return DFB_DESTROYED;     config.dst_geometry = *geometry;     return dfb_window_set_config( data->window, &config, CWCF_DST_GEOMETRY );}

static DFBResultprimaryFlipRegion( CoreLayer             *layer,                   void                  *driver_data,                   void                  *layer_data,                   void                  *region_data,                   CoreSurface           *surface,                   DFBSurfaceFlipFlags    flags,                   CoreSurfaceBufferLock *left_lock,                   CoreSurfaceBufferLock *right_lock ){     DFBX11       *x11    = driver_data;     DFBX11Shared *shared = x11->shared;     X11LayerData *lds    = layer_data;     D_DEBUG_AT( X11_Layer, "%s()/n", __FUNCTION__ );     dfb_surface_flip( surface, false );     lds->shown = true;     return DisplaySurface( x11, layer_data, shared->vdp_queue, left_lock );}

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 (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 );}

static intdfb_core_arena_shutdown( FusionArena *arena,                         void        *ctx,                         bool         emergency){     DFBResult            ret;     CoreDFB             *core = ctx;     CoreDFBShared       *shared;     FusionSHMPoolShared *pool;     D_MAGIC_ASSERT( core, CoreDFB );     shared = core->shared;     D_MAGIC_ASSERT( shared, CoreDFBShared );     pool = shared->shmpool;     D_DEBUG_AT( DirectFB_Core, "Shutting down.../n" );     if (!core->master) {          D_WARN( "refusing shutdown in slave" );          return dfb_core_leave( core, emergency );     }     CoreDFB_Deinit_Dispatch( &shared->call );     /* Shutdown. */     ret = dfb_core_shutdown( core, emergency );     fusion_skirmish_destroy( &shared->lock );     D_MAGIC_CLEAR( shared );     SHFREE( pool, shared );     fusion_shm_pool_destroy( core->world, pool );     return ret;}

static DFBResultIDirectFBDisplayLayer_GetScreen( IDirectFBDisplayLayer  *thiz,                                 IDirectFBScreen       **interface ){     DFBResult        ret;     IDirectFBScreen *screen;     D_DEBUG_AT( Layer, "%s( %p )/n", __FUNCTION__, thiz );     DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)     if (!interface)          return DFB_INVARG;     DIRECT_ALLOCATE_INTERFACE( screen, IDirectFBScreen );     ret = IDirectFBScreen_Construct( screen, data->screen );     *interface = ret ? NULL : screen;     return ret;}

DFBResultIWindow_Real::GetSurface(                    CoreSurface                              **ret_surface){     DFBResult ret;     D_DEBUG_AT( Core_Window, "IWindow_Real::%s( %p )/n", __FUNCTION__, obj );     D_ASSERT( ret_surface != NULL );     if (!obj->surface)          return DFB_UNSUPPORTED;     ret = (DFBResult) dfb_surface_ref( obj->surface );     if (ret)          return ret;     *ret_surface = obj->surface;     return DFB_OK;}

static DFBResultIDirectFBDisplayLayer_SetScreenPosition( IDirectFBDisplayLayer *thiz,                                         int                    x,                                         int                    y ){     DFBPoint position;     D_DEBUG_AT( Layer, "%s( %p )/n", __FUNCTION__, thiz );     DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)     if (! D_FLAGS_IS_SET( data->desc.caps, DLCAPS_SCREEN_POSITION ))          return DFB_UNSUPPORTED;     if (data->level == DLSCL_SHARED)          return DFB_ACCESSDENIED;     position.x = x;     position.y = y;     return CoreLayerContext_SetScreenPosition( data->context, &position );}