Used in processcontext_INIT_STATIC to initialize static processcontext_t.
extern uint8_t g_errorcontext_strdata[]
Used in processcontext_INIT_STATIC to initialize static processcontext_t.
extern uint16_t g_errorcontext_stroffset[]
Adapted interface (see log_it) to static log service.
extern struct log_it g_logmain_interface
Contains single instance of interface log_it.
log_it g_logmain_interface
Global variable which describes the main context for the current process.
extern struct maincontext_t g_maincontext
Stores the length in bytes of an encoded utf8 character indexed by the first encoded byte.
extern uint8_t g_utf8_bytesperchar[256]
Adapt wbuffer_t to use cstring_t as buffer.
extern wbuffer_it g_wbuffer_cstring
Adapt wbuffer_t to use memblock_t as buffer.
extern wbuffer_it g_wbuffer_memblock
Adapt wbuffer_t to a static buffer.
extern wbuffer_it g_wbuffer_static
Static initializer.
#define gconfig_filter_INIT( accept, user ) { user, accept }
Declares filter to select between different possible configuration.
typedef struct gconfig_filter_t gconfig_filter_t
Static initializer.
#define gconfig_FREE { 0 }
Static initializer.
#define gconfig_INIT( glconfig ) { glconfig }
Contains a specific surface configuration.
struct gconfig_t
Static initializer.
#define gcontext_FREE { 0 }
Wraps the native implementation of an OpenGL context.
struct gcontext_t
Implements dlist_t.genericcast_dlist.
#define genericcast_dlist( list ) ( __extension__ ({ static_assert( sizeof((list)->last) == sizeof(((dlist_t*)0)->last) && offsetof(typeof(*(list)), last) == offsetof(dlist_t, last) && (typeof((list)->last))0 == (dlist_node_t*)0, "ensure compatible structure" ) ; (dlist_t*) (list) ; }))
Casts list into dlist_t if that is possible.
dlist_t * genericcast_dlist( void * list )
Casts node into pointer to dlist_node_t.
dlist_node_t * genericcast_dlistnode( void * node )
Implements errorcontext_t.genericcast_errorcontext.
#define genericcast_errorcontext( object ) ( __extension__ ({ typeof(object) _obj = (object) ; errorcontext_t * _errcon = 0 ; static_assert( sizeof(_errcon->stroffset) == sizeof(_obj->stroffset) && sizeof((_errcon->stroffset)[0]) == sizeof((_obj->stroffset)[0]) && offsetof(errorcontext_t, stroffset) == offsetof(typeof(*_obj), stroffset) && sizeof(_errcon->strdata) == sizeof(_obj->strdata) && sizeof(_errcon->strdata[0]) == sizeof(_obj->strdata[0]) && offsetof(errorcontext_t, strdata) == offsetof(typeof(*_obj), strdata), "members are compatible") ; if (0) { volatile uint16_t _off ; volatile uint8_t _str ; _off = _obj->stroffset[0] ; _str = _obj->strdata[_off] ; (void) _str ; } (void) _errcon ; (errorcontext_t *)(_obj) ; }))
Casts a pointer to generic object into pointer to errorcontext_t.
errorcontext_t * genericcast_errorcontext( void * object )
Implements iobj_t.genericcast_iobj.
#define genericcast_iobj( iobj, typenameprefix ) ( __extension__ ({ static_assert( &((typeof(iobj))0)->object == ((struct typenameprefix##_t**) offsetof(iobj_t, object)) && &((typeof(iobj))0)->iimpl == ((struct typenameprefix##_it**) offsetof(iobj_t, iimpl)), "compatible structure") ; (typenameprefix##_t*) (iobj) ; }))
Casts pointer to an interfaceable object to its standard type name.
void * genericcast_iobj( void * iobj, IDNAME typenameprefix )
Implements iocallback_t.genericcast_iocallback.
#define genericcast_iocallback( iocb, iohandler_t ) ( __extension__ ({ static_assert( offsetof(iocallback_t, object) == offsetof(typeof(*(iocb)), object) && (typeof((iocb)->object)*)0 == (iohandler_t**)0 && offsetof(iocallback_t, iimpl) == offsetof(typeof(*(iocb)), iimpl) && (typeof((iocb)->iimpl)*)0 == (void(**)(iohandler_t*, sys_iochannel_t, uint8_t))0, "ensure same structure") ; (iocallback_t*) (iocb) ; }))
Casts parameter iocb into pointer to iocallback_t.
iocallback_t * genericcast_iocallback( void * iocb, TYPENAME iohandler_t ) ;
Implements log_t.genericcast_log.
#define genericcast_log( iobj ) genericcast_iobj(iobj, log)
Casts parameter iobj to pointer to log_t.
log_t * genericcast_log( void * iobj )
Implements log_it.genericcast_logit.
#define genericcast_logit( logif, log_t ) ( __extension__ ({ static_assert( &((typeof(logif))0)->printf == (void(**)(log_t*,uint8_t,uint8_t, const log_header_t*, const char*,...)) &((log_it*)0)->printf && &((typeof(logif))0)->printtext == (void(**)(log_t*,uint8_t,uint8_t, const log_header_t*, log_text_f,...)) &((log_it*)0)->printtext && &((typeof(logif))0)->flushbuffer == (void(**)(log_t*,uint8_t)) &((log_it*)0)->flushbuffer && &((typeof(logif))0)->clearbuffer == (void(**)(log_t*,uint8_t)) &((log_it*)0)->clearbuffer && &((typeof(logif))0)->getbuffer == (void(**)(const log_t*,uint8_t, uint8_t**,size_t*)) &((log_it*)0)->getbuffer && &((typeof(logif))0)->getstate == (uint8_t(**)(const log_t*, uint8_t)) &((log_it*)0)->getstate && &((typeof(logif))0)->compare == (int(**)(const log_t*, uint8_t, size_t,const uint8_t*)) &((log_it*)0)->compare && &((typeof(logif))0)->setstate == (void(**)(log_t*,uint8_t, uint8_t)) &((log_it*)0)->setstate, "ensure same structure"); (log_it*) (logif); }))
Casts pointer logif into pointer to interface log_it.
log_it * genericcast_logit( void * logif, TYPENAME log_t )
Implements memblock_t.genericcast_memblock.
#define genericcast_memblock( obj, nameprefix ) ( __extension__ ({ typeof(obj) _obj = (obj) ; static_assert( sizeof(_obj->nameprefix##addr) == sizeof(((memblock_t*)0)->addr) && offsetof(memblock_t, addr) == 0 && (typeof(_obj->nameprefix##addr))10 == (uint8_t*)10 && sizeof(_obj->nameprefix##size) == sizeof(((memblock_t*)0)->size) && offsetof(memblock_t, size) == ((uintptr_t)&_obj->nameprefix##size) -((uintptr_t)&_obj->nameprefix##addr) && (typeof(_obj->nameprefix##size)*)10 == (size_t*)10, "obj is compatible") ; (memblock_t *)(&_obj->nameprefix##addr) ; }))
Casts a pointer to generic object into pointer to memblock_t.
memblock_t * genericcast_memblock( void * obj, IDNAME nameprefix )
Implements memstream_t.genericcast_memstream.
#define genericcast_memstream( obj, nameprefix ) ( __extension__ ({ typeof(obj) _obj = (obj) ; static_assert( &((memstream_t*)((uintptr_t) &_obj->nameprefix##next))->next == &_obj->nameprefix##next && &((memstream_t*)((uintptr_t) &_obj->nameprefix##next))->end == &_obj->nameprefix##end, "obj is compatible") ; (memstream_t *)(&_obj->nameprefix##next) ; }))
Casts pointer obj into pointer to memstream_t.
memstream_t * genericcast_memstream( void * obj, IDNAME nameprefix )
Implements mmfile_t.genericcast_mmfile.
#define genericcast_mmfile( obj, nameprefix, qualifier ) ( __extension__ ({ typeof(obj) _obj = (obj) ; static_assert( sizeof(_obj->nameprefix##addr) == sizeof(((mmfile_t*)0)->addr) && 0 == offsetof(mmfile_t, addr), && (typeof(_obj->nameprefix##addr)*)0 == (uint8_t**)0 && sizeof(_obj->nameprefix##size) == sizeof(((mmfile_t*)0)->size) && offsetof(mmfile_t, size) == ((uintptr_t)&_obj->nameprefix##size) -((uintptr_t)&_obj->nameprefix##addr) && (typeof(_obj->nameprefix##size)*)0 == (size_t**)0 "structure is compatible") ; (qualifier mmfile_t *)(&_obj->nameprefix##addr) ; }))
Casts a generic object pointer into pointer to memblock_t.
mmfile_t * genericcast_mmfile( void * obj, IDNAME nameprefix, TYPEQUALIFIER qualifier )
Implements mm_it.genericcast_mmit.
#define genericcast_mmit( mminterface, memorymanager_t ) ( __extension__ ({ static_assert( &((typeof(mminterface))0)->malloc == (int (**) (memorymanager_t*, size_t, struct memblock_t*)) &((mm_it*)0)->malloc && &((typeof(mminterface))0)->mresize == (int (**) (memorymanager_t*, size_t, struct memblock_t*)) &((mm_it*)0)->mresize && &((typeof(mminterface))0)->mfree == (int (**) (memorymanager_t*, struct memblock_t*)) &((mm_it*)0)->mfree && &((typeof(mminterface))0)->sizeallocated == (size_t (**) (memorymanager_t*)) &((mm_it*)0)->sizeallocated, "ensure same structure") ; (mm_it*) (mminterface) ; }))
Casts parameter mminterface into pointer to interface mm_it.
mm_it * genericcast_mmit( void * mminterface, TYPENAME memorymanager_t )
Implements objectcache_it.genericcast_objectcacheit.
#define genericcast_objectcacheit( cache, objectcache_t ) ( __extension__ ({ static_assert( offsetof(objectcache_it, lock_iobuffer) == offsetof(typeof(*(cache)), lock_iobuffer) && offsetof(objectcache_it, unlock_iobuffer) == offsetof(typeof(*(cache)), unlock_iobuffer), "ensure same structure") ; if (0) { (cache)->lock_iobuffer((objectcache_t*)0, (struct memblock_t**)0) ; (cache)->unlock_iobuffer((objectcache_t*)0, (struct memblock_t**)0) ; } (objectcache_it*) (cache) ; }))
Casts first parameter into pointer to objectcache_it.
objectcache_it * genericcast_objectcacheit( void * cache, TYPENAME objectcache_t ) ;
Implements pagecache_it.genericcast_pagecacheit.
#define genericcast_pagecacheit( pgcacheif, pagecache_t ) ( __extension__ ({ static_assert( offsetof(typeof(*(pgcacheif)), allocpage) == offsetof(pagecache_it, allocpage) && offsetof(typeof(*(pgcacheif)), releasepage) == offsetof(pagecache_it, releasepage) && offsetof(typeof(*(pgcacheif)), sizeallocated) == offsetof(pagecache_it, sizeallocated) && offsetof(typeof(*(pgcacheif)), allocstatic) == offsetof(pagecache_it, allocstatic) && offsetof(typeof(*(pgcacheif)), freestatic) == offsetof(pagecache_it, freestatic) && offsetof(typeof(*(pgcacheif)), sizestatic) == offsetof(pagecache_it, sizestatic) && sizeof(int) == sizeof((pgcacheif)->allocpage( (pagecache_t*)0, pagesize_16384, (struct memblock_t*)0)) && sizeof(int) == sizeof((pgcacheif)->releasepage( (pagecache_t*)0, (struct memblock_t*)0)) && sizeof(size_t) == sizeof((pgcacheif)->sizeallocated( (const pagecache_t*)0)) && sizeof(int) == sizeof((pgcacheif)->allocstatic( (pagecache_t*)0, (size_t)0, (struct memblock_t*)0)) && sizeof(int) == sizeof((pgcacheif)->freestatic( (pagecache_t*)0, (struct memblock_t*)0)) && sizeof(size_t) == sizeof((pgcacheif)->sizestatic( (const pagecache_t*)0)) && sizeof(int) == sizeof((pgcacheif)->emptycache( (pagecache_t*)0)), "ensure same structure") ; if (0) { int _err ; size_t _err2 ; _err = (pgcacheif)->allocpage( (pagecache_t*)0, pagesize_16384, (struct memblock_t*)0) ; _err += (pgcacheif)->releasepage( (pagecache_t*)0, (struct memblock_t*)0) ; _err2 = (pgcacheif)->sizeallocated( (const pagecache_t*)0) ; _err += (pgcacheif)->allocstatic( (pagecache_t*)0, (size_t)128, (struct memblock_t *)0) ; _err += (pgcacheif)->freestatic( (pagecache_t*)0, (struct memblock_t *)0) ; _err2 += (pgcacheif)->sizestatic( (const pagecache_t*)0) ; _err += (pgcacheif)->emptycache( (pagecache_t*)0) ; _err2 += (size_t)_err ; (void) _err2 ; } (pagecache_it*) (pgcacheif) ; }))
Casts pointer pgcacheif into pointer to interface pagecache_it.
pagecache_it * genericcast_pagecacheit( void * pgcacheif, TYPENAME pagecache_t )
Implements queue_t.genericcast_queue.
#define genericcast_queue( queue ) ( __extension__ ({ static_assert( sizeof((queue)->last) == sizeof(((queue_t*)0)->last) && offsetof(typeof(*(queue)), last) == offsetof(queue_t, last) && (typeof((queue)->last))0 == (struct dlist_node_t*)0, "ensure compatible structure" ) ; (queue_t*) (queue) ; }))
Tries to cast generic object queue into pointer to queue_t.
queue_t * genericcast_queue( void * queue )
Implements slist_t.genericcast_slist.
#define genericcast_slist( list ) ( __extension__ ({ static_assert(offsetof(typeof(*(list)), last) == offsetof(slist_t, last), "ensure same structure") ; static_assert((typeof((list)->last))0 == (slist_node_t*)0, "ensure same type") ; (slist_t*) (list) ; }))
Casts list into slist_t if that is possible.
slist_t * genericcast_slist( void * list )
Implements splaytree_t.genericcast_splaytree.
#define genericcast_splaytree( tree ) ( __extension__ ({ static_assert(offsetof(splaytree_t, root) == 0, "first member") ; static_assert((typeof((tree)->root))0 == (splaytree_node_t*)0, "ensure same type") ; (splaytree_t*) &(tree)->root ; }))
Casts tree into slaytree_t if that is possible.
splaytree_t * genericcast_splaytree( void * tree )
Casts a pointer to generic obj type into pointer to string_t.
const string_t * genericcast_string( const void * obj )
Implements stringstream_t.genericcast_stringstream.
#define genericcast_stringstream( strstream ) ( __extension__({ typeof(strstream) _obj = (strstream) ; static_assert( ((uint8_t*)&_obj->end) - ((uint8_t*)&_obj->next) == offsetof(stringstream_t, end) && sizeof(_obj->next) == sizeof(void*) && sizeof(_obj->end) == sizeof(void*), "member next and member end in that order") ; if (0) { volatile uint8_t _b1 ; volatile uint8_t _b2 ; _b1 = _obj->next[0] ; _b2 = _obj->end[0] ; (void) (_b1 + _b2) ; } (stringstream_t*)(&_obj->next) ; }))
Converts pointer to strstream of any type to pointer to stringstream_t.
stringstream_t * genericcast_stringstream( void * strstream )
Implements thread_tls_t.genericcast_threadtls.
#define genericcast_threadtls( obj, nameprefix ) ( __extension__ ({ typeof(obj) _obj = (obj) ; static_assert( sizeof(_obj->nameprefix##addr) == sizeof(((thread_tls_t*)0)->addr) && (typeof(_obj->nameprefix##addr))10 == (uint8_t*)10 && 0 == offsetof(thread_tls_t, addr), "obj is compatible") ; (thread_tls_t *)(&_obj->nameprefix##addr) ; }))
Casts pointer to an object into pointer to thread_tls_t.
thread_tls_t * genericcast_threadtls( void * obj, IDNAME nameprefix )
Implements typeadapt_t.genericcast_typeadapt.
#define genericcast_typeadapt( typeadp, typeadapter_t, object_t, key_t ) ( __extension__ ({ static_assert( offsetof(typeof(*(typeadp)), comparator) == offsetof(typeadapt_t, comparator) && offsetof(typeof(*(typeadp)), gethash) == offsetof(typeadapt_t, gethash) && offsetof(typeof(*(typeadp)), getkey) == offsetof(typeadapt_t, getkey) && offsetof(typeof(*(typeadp)), lifetime) == offsetof(typeadapt_t, lifetime), "ensure same structure") ; if (0) { (void) genericcast_typeadaptcomparator((typeof((typeadp)->comparator)*)0, typeadapter_t, object_t, key_t) ; (void) genericcast_typeadaptgethash((typeof((typeadp)->gethash)*)0, typeadapter_t, object_t, key_t) ; (void) genericcast_typeadaptgetkey((typeof((typeadp)->getkey)*)0, typeadapter_t, object_t) ; (void) genericcast_typeadaptlifetime((typeof((typeadp)->lifetime)*)0, typeadapter_t, object_t) ; } (typeadapt_t*) (typeadp) ; }))
Casts parameter typeadp into pointer to typeadapt_t.
typeadapt_t * genericcast_typeadapt( void * typeadp, TYPENAME testadapter_t, TYPENAME object_t )
Implements typeadapt_binarykey_t.genericcast_typeadaptbinarykey.
#define genericcast_typeadaptbinarykey( conststr ) ( __extension__ ({ typeof(conststr) _conststr = (conststr) ; static_assert( offsetof(typeadapt_binarykey_t, addr) == offsetof(typeof(*(conststr)), addr) && offsetof(typeadapt_binarykey_t, size) == offsetof(typeof(*(conststr)), size), "ensure same structure") ; if (0) { int _err = 0 ; const uint8_t * _addr = _conststr->addr ; size_t _size = _conststr->size ; _err = (int) (_addr[0] + _size) ; (void) _err ; } (typeadapt_binarykey_t*) _conststr ; }))
Casts parameter conststr into pointer to typeadapt_binarykey_t.
typeadapt_binarykey_t * genericcast_typeadaptbinarykey( void * conststr )
Implements typeadapt_comparator_it.genericcast_typeadaptcomparator.
#define genericcast_typeadaptcomparator( adpcmp, typeadapter_t, object_t, key_t ) ( __extension__ ({ static_assert( offsetof(typeadapt_comparator_it, cmp_key_object) == offsetof(typeof(*(adpcmp)), cmp_key_object) && offsetof(typeadapt_comparator_it, cmp_object) == offsetof(typeof(*(adpcmp)), cmp_object), "ensure same structure") ; if (0) { int _err = (adpcmp)->cmp_key_object((typeadapter_t*)0, (const key_t)0, (const object_t*)0) ; _err += (adpcmp)->cmp_object((typeadapter_t*)0, (const object_t*)0, (const object_t*)0) ; (void) _err ; } (typeadapt_comparator_it*) (adpcmp) ; }))
Casts parameter adpcmp into pointer to typeadapt_comparator_it.
typeadapt_comparator_it * genericcast_typeadaptcomparator( void * adpcmp, TYPENAME typeadapter_t, TYPENAME object_t, TYPENAME key_t ) ;
Implements typeadapt_gethash_it.genericcast_typeadaptgethash.
#define genericcast_typeadaptgethash( gethash, typeadapter_t, object_t, key_t ) ( __extension__ ({ static_assert( offsetof(typeadapt_gethash_it, hashobject) == offsetof(typeof(*(gethash)), hashobject) && offsetof(typeadapt_gethash_it, hashkey) == offsetof(typeof(*(gethash)), hashkey), "ensure same structure") ; if (0) { size_t hash = 0 ; hash += (gethash)->hashobject((typeadapter_t*)0, (const object_t*)0) ; hash += (gethash)->hashkey((typeadapter_t*)0, (const key_t)0) ; } (typeadapt_gethash_it*) (gethash) ; }))
Casts parameter gethash into pointer to typeadapt_gethash_it.
typeadapt_gethash_it * genericcast_typeadaptgethash( void * gethash, TYPENAME typeadapter_t, TYPENAME object_t, TYPENAME key_t ) ;
Implements typeadapt_getkey_it.genericcast_typeadaptgetkey.
#define genericcast_typeadaptgetkey( adpgetkey, typeadapter_t, object_t ) ( __extension__ ({ static_assert( offsetof(typeadapt_getkey_it, getbinarykey) == offsetof(typeof(*(adpgetkey)), getbinarykey), "ensure same structure") ; if (0) { (adpgetkey)->getbinarykey( (typeadapter_t*)0, (object_t*)0, (typeadapt_binarykey_t*)0) ; } (typeadapt_getkey_it*) (adpgetkey) ; }))
Casts parameter adpgetkey into pointer to typeadapt_getkey_it.
typeadapt_getkey_it * genericcast_typeadaptgetkey( void * adpgetkey, TYPENAME typeadapter_t, TYPENAME object_t ) ;
Implements typeadapt_lifetime_it.genericcast_typeadaptlifetime.
#define genericcast_typeadaptlifetime( adplife, typeadapter_t, object_t ) ( __extension__ ({ static_assert( offsetof(typeadapt_lifetime_it, newcopy_object) == offsetof(typeof(*(adplife)), newcopy_object) && offsetof(typeadapt_lifetime_it, delete_object) == offsetof(typeof(*(adplife)), delete_object), "ensure same structure") ; if (0) { int _err = (adplife)->newcopy_object((typeadapter_t*)0, (object_t**)0, (const object_t*)0) ; _err += (adplife)->delete_object((typeadapter_t*)0, (object_t**)0) ; (void) _err ; } (typeadapt_lifetime_it*) (adplife) ; }))
Casts parameter adplife into pointer to typeadapt_lifetime_it.
typeadapt_lifetime_it * genericcast_typeadaptlifetime( void * adplife, TYPENAME typeadapter_t, TYPENAME object_t ) ;
Implements vmpage_t.genericcast_vmpage.
#define genericcast_vmpage( obj, nameprefix ) ( __extension__ ({ typeof(obj) _obj = (obj) ; static_assert( sizeof(_obj->nameprefix##addr) == sizeof(((vmpage_t*)0)->addr) && 0 == offsetof(vmpage_t, addr), "addr member is compatible") ; static_assert( sizeof(_obj->nameprefix##size) == sizeof(((vmpage_t*)0)->size) && offsetof(vmpage_t, size) == ((uintptr_t)&_obj->nameprefix##size) -((uintptr_t)&_obj->nameprefix##addr), "size member is compatible") ; if (0) { volatile uint8_t _err ; volatile size_t _size ; _size = _obj->nameprefix##size ; _err = _obj->nameprefix##addr[_size] ; (void) _err ; } (vmpage_t *)(&_obj->nameprefix##addr) ; }))
Casts a pointer to an compatible object into pointer to vmpage_t.
vmpage_t * genericcast_vmpage( void * obj, IDNAME nameprefix )
Implements window_evh_t.genericcast_windowevh.
#define genericcast_windowevh( evhimpl, subwindow_t ) ( __extension__ ({ static_assert( offsetof(typeof(*(evhimpl)), onclose) == offsetof(window_evh_t, onclose) && offsetof(typeof(*(evhimpl)),ondestroy) == offsetof(window_evh_t, ondestroy) && offsetof(typeof(*(evhimpl)), onredraw) == offsetof(window_evh_t, onredraw) && offsetof(typeof(*(evhimpl)),onreshape) == offsetof(window_evh_t, onreshape) && offsetof(typeof(*(evhimpl)),onvisible) == offsetof(window_evh_t, onvisible), "ensure same structure"); if (0) { (evhimpl)->onclose((subwindow_t*)0); (evhimpl)->ondestroy((subwindow_t*)0); (evhimpl)->onredraw((subwindow_t*)0); (evhimpl)->onreshape((subwindow_t*)0, (uint32_t)0, (uint32_t)0); (evhimpl)->onvisible((subwindow_t*)0, (bool)0); } (const window_evh_t*) (evhimpl); }))
Casts parameter evhimpl into pointer to interface window_evh_t.
const window_evh_t * genericcast_windowevh( const void * evhimpl, TYPENAME subwindow_t )
Casts drawable into pointer to x11drawable_t if that is possible.
x11drawable_t* genericcast_x11drawable( void * drawable )
Implements x11window_t.genericcast_x11window.
#define genericcast_x11window( object ) ( __extension__ ({ static_assert( offsetof(typeof(*(object)), display) == offsetof(x11window_t, display) && offsetof(typeof(*(object)), sys_drawable) == offsetof(x11window_t, sys_drawable) && offsetof(typeof(*(object)), sys_colormap) == offsetof(x11window_t, sys_colormap) && offsetof(typeof(*(object)), evhimpl) == offsetof(x11window_t, evhimpl) && offsetof(typeof(*(object)), state) == offsetof(x11window_t, state) && offsetof(typeof(*(object)), flags) == offsetof(x11window_t, flags) && sizeof((object)->flags) == sizeof(((x11window_t*)0)->flags), "ensure same structure") ; (x11window_t *) (object) ; }))
Casts a pointer to object into a pointer to x11window_t.
x11window_t * genericcast_x11window( void * object )
Implements x11window_evh_t.genericcast_x11windowevh.
#define genericcast_x11windowevh( evhimpl, subwindow_t ) ( __extension__ ({ static_assert( offsetof(typeof(*(evhimpl)), onclose) == offsetof(x11window_evh_t, onclose) && offsetof(typeof(*(evhimpl)), ondestroy) == offsetof(x11window_evh_t, ondestroy) && offsetof(typeof(*(evhimpl)), onredraw) == offsetof(x11window_evh_t, onredraw) && offsetof(typeof(*(evhimpl)), onreshape) == offsetof(x11window_evh_t, onreshape) && offsetof(typeof(*(evhimpl)), onvisible) == offsetof(x11window_evh_t, onvisible), "ensure same structure"); if (0) { (evhimpl)->onclose((subwindow_t*)0); (evhimpl)->ondestroy((subwindow_t*)0); (evhimpl)->onredraw((subwindow_t*)0); (evhimpl)->onreshape((subwindow_t*)0, (uint32_t)0, (uint32_t)0); (evhimpl)->onvisible((subwindow_t*)0, (bool)0); } (const x11window_evh_t*) (evhimpl); }))
Casts parameter evhimpl into pointer to interface x11window_evh_t.
const x11window_evh_t * genericcast_x11windowevh( const void * evhimpl, TYPENAME subwindow_t )
This is the geometry of x11win without the window manager frame in screen coordinates.
int geometry_x11window( const x11window_t * x11win, /*out*/int32_t * screen_x, /*out*/int32_t * screen_y, /*out*/uint32_t * width, /*out*/uint32_t * height )
Returns in typeadapt_binarykey_t the description of a binary key.
void ( * getbinarykey ) (struct typeadapt_t * typeadp, struct typeadapt_object_t * node, /*out*/typeadapt_binarykey_t * binkey)
Returns content of log buffer as C-string and its size in bytes.
void ( * getbuffer ) (const void * log, uint8_t channel, /*out*/uint8_t ** buffer, /*out*/size_t * size)
See GETBUFFER_LOG.
#define GETBUFFER_ERRLOG( buffer, size ) GETBUFFER_LOG(log_channel_ERR, buffer, size)
Returns C-string of buffered log and its length.
#define GETBUFFER_LOG( LOGCHANNEL, /*out char ** */buffer, /*out size_t * */size ) log_maincontext().iimpl->getbuffer(log_maincontext().object, LOGCHANNEL, buffer, size)
Implements logbuffer_t.getbuffer_logbuffer.
#define getbuffer_logbuffer( logbuf, _addr, _logsize ) ( __extension__ ({ const logbuffer_t * _lb ; _lb = (logbuf) ; *(_addr) = _lb->addr ; *(_logsize) = _lb->logsize ; }))
Returns the start address of the memory buffer and size of written log.
void getbuffer_logbuffer( const logbuffer_t * logbuf, /*out*/uint8_t ** addr, /*out*/size_t * logsize )
Returns content of internal buffer corrseponding to channel as C-string.
void getbuffer_logwriter( const logwriter_t * lgwrt, uint8_t channel, /*out*/uint8_t ** buffer, /*out*/size_t * size )
Returns interrupt mask fpu register value.
fpu_except_e getenabled_fpuexcept( void )
Interface to adapt reading of a hash value.
typeadapt_gethash_it gethash
Implements patriciatrie_t.getinistate_patriciatrie.
static inline void getinistate_patriciatrie( const patriciatrie_t * tree, /*out*/patriciatrie_node_t ** root, /*out*/typeadapt_member_t * nodeadp )
Returns the current state of patriciatrie_t for later use in patriciatrie_INIT.
static inline void getinistate_patriciatrie( const patriciatrie_t * tree, /*out*/patriciatrie_node_t ** root, /*out*/typeadapt_member_t * nodeadp/*0 = >ignored*/ )
Implements redblacktree_t.getinistate_redblacktree.
static inline void getinistate_redblacktree( const redblacktree_t * tree, /*out*/redblacktree_node_t ** root, /*out*/typeadapt_member_t * nodeadp )
Returns the current state of redblacktree_t for later use in redblacktree_INIT.
static inline void getinistate_redblacktree( const redblacktree_t * tree, /*out*/redblacktree_node_t ** root, /*out*/typeadapt_member_t * nodeadp/*0 = >ignored*/ )
Implements splaytree_t.getinistate_splaytree.
static inline void getinistate_splaytree( const splaytree_t * tree, /*out*/splaytree_node_t ** root )
Returns the current state of splaytree_t for later use in splaytree_INIT.
static inline void getinistate_splaytree( const splaytree_t * tree, /*out*/splaytree_node_t ** root )
Interface to adapt reading of a key as binary data.
typeadapt_getkey_it getkey
Return part of url as string.
const char * getpart_url( const url_t * url, enum url_part_e part )
Returns the current segmentation fault signal handler.
signalhandler_segv_f getsegv_signalhandler( void )
Returns signaled interrupt flags fpu register value.
fpu_except_e getsignaled_fpuexcept( fpu_except_e exception_mask )
Returns configured log_state_e for a specific log_channel_e channel.
uint8_t ( * getstate ) (const void * log, uint8_t channel)
Returns log_state_e for LOGCHANNEL.
#define GETSTATE_LOG( LOGCHANNEL ) log_maincontext().iimpl->getstate(log_maincontext().object, LOGCHANNEL)
Returns current log_state_e of channel (log_channel_e).
uint8_t getstate_logwriter( const logwriter_t * lgwrt, uint8_t channel )
Implements display_t.gl_display.
#define gl_display( disp ) ((disp)->gldisplay)
Returns a pointer to a native opengl display.
struct opengl_display_t * gl_display( const display_t * disp )
Implements gconfig_t.gl_gconfig.
#define gl_gconfig( gconf ) ((gconf)->glconfig)
Returns the native OpenGL surface config.
struct opengl_config_t * gl_gconfig( const gconfig_t * gconf )
Implements gcontext_t.gl_gcontext.
#define gl_gcontext( cont ) ((cont)->glcontext)
Returns the native OpenGL context.
struct opengl_context_t * gl_gcontext( const gcontext_t * cont )
Implements pixelbuffer_t.gl_pixelbuffer.
#define gl_pixelbuffer( win ) gl_surface(win)
Returns a pointer to a native opengl window.
struct opengl_window_t * gl_pixelbuffer( const pixelbuffer_t * pbuf )
Implements surface_t.gl_surface.
#define gl_surface( surf ) ((surf)->glsurface)
Returns the native OpenGL surface type tagged with (opengl_surface_t*).
struct opengl_surface_t * gl_surface( surface_t * surf )
Implements window_t.gl_window.
#define gl_window( win ) gl_surface(win)
Returns a pointer to a native opengl window.
struct opengl_surface_t * gl_window( const window_t * win )
Sets the current read position to the begin of the directory stream.
int gofirst_directory( directory_t * dir )
Resets iterator to first ipaddr_t of internal list of addresses.
void gofirst_ipaddrlist( ipaddr_list_t * addrlist )
Resets iterator to the first element.
void gofirst_vmmappedregions( vm_mappedregions_t * iterator )
Resets iterator to first element.
void gofirst_x11videomodeiterator( x11videomode_iterator_t * xvidit )
Grows the memory block by decr its addr and incr its size..
int growleft_memblock( memblock_t * mblock, size_t addr_decrement )
Adds increment to length of prefix.
static void growprefix_trienodesoffsets( trie_nodeoffsets_t * offsets, uint8_t increment, bool usefreechild )
Implements memblock_t.growright_memblock.
#define growright_memblock( mblock, size_increment ) ( __extension__ ({ int _err ; typeof(mblock) _mblock = (mblock) ; size_t _size = _mblock->size + (size_increment) ; if ( _size < _mblock->size || ((uintptr_t)_mblock->addr + _size < (uintptr_t)_mblock->addr)) { _err = ENOMEM ; } else { _mblock->size = _size ; _err = 0 ; } _err ; }))
Grows the memory block by incrementing only its size.
int growright_memblock( memblock_t * mblock, size_t size_increment )