#define gconfig_filter_INIT( accept, user ) { user, accept }

#define gconfig_FREE { 0 }

#define gconfig_INIT( glconfig ) { glconfig }

#define gcontext_FREE { 0 }

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

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

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

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

iocallback_t * genericcast_iocallback( void  * iocb, TYPENAME  iohandler_t ) ;

#define genericcast_log( iobj ) genericcast_iobj(iobj, log)

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

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

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

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

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

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

objectcache_it * genericcast_objectcacheit( void  * cache, TYPENAME  objectcache_t ) ;

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

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

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

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

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

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

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

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

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

typeadapt_comparator_it * genericcast_typeadaptcomparator(     void  * adpcmp,     TYPENAME  typeadapter_t,     TYPENAME  object_t,     TYPENAME  key_t ) ;

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

typeadapt_gethash_it * genericcast_typeadaptgethash( void  * gethash, TYPENAME  typeadapter_t, TYPENAME  object_t, TYPENAME  key_t ) ;

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

typeadapt_getkey_it * genericcast_typeadaptgetkey( void  * adpgetkey, TYPENAME  typeadapter_t, TYPENAME  object_t ) ;

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

typeadapt_lifetime_it * genericcast_typeadaptlifetime( void  * adplife, TYPENAME  typeadapter_t, TYPENAME  object_t ) ;

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

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

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

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

#define GETBUFFER_ERRLOG( buffer, size ) GETBUFFER_LOG(log_channel_ERR, buffer, size)

#define GETBUFFER_LOG(       LOGCHANNEL,     /*out  char  ** */buffer,     /*out  size_t  * */size ) log_maincontext().iimpl->getbuffer(log_maincontext().object, LOGCHANNEL, buffer, size)

#define getbuffer_logbuffer(     logbuf,     _addr,     _logsize ) ( __extension__ ({ const logbuffer_t * _lb ; _lb = (logbuf) ; *(_addr) = _lb->addr ; *(_logsize) = _lb->logsize ; }))

#define GETSTATE_LOG(     LOGCHANNEL ) log_maincontext().iimpl->getstate(log_maincontext().object, LOGCHANNEL)

#define gl_display( disp ) ((disp)->gldisplay)

#define gl_gconfig( gconf ) ((gconf)->glconfig)

#define gl_gcontext( cont ) ((cont)->glcontext)

#define gl_pixelbuffer( win ) gl_surface(win)

#define gl_surface( surf ) ((surf)->glsurface)

#define gl_window( win ) gl_surface(win)

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