#define SCNuSIZE "zu"

scanf unsigned int format specifier ‘zu’ for type size_t.

#define self_maincontext( ) ((maincontext_t*)pcontext_maincontext())

Inline implementation of maincontext_t.self_maincontext.

#define self_thread( ) (sys_thread_threadtls())

Implements thread_t.self_thread.

#define semaphore_FREE { sys_semaphore_FREE }

Static initializer.

#define sendclose_window( win ) sendclose_x11window(os_window(win))

Implements window_t.sendclose_window.

#define sendredraw_window( win ) sendredraw_x11window(os_window(win))

Implements window_t.sendredraw_window.

#define SET_PROT(     prot,     access_mode ) static_assert(0 == accessmode_NONE, "") ; static_assert(0 == PROT_NONE, "") ; if ( accessmode_READ == PROT_READ && accessmode_WRITE == PROT_WRITE && accessmode_EXEC == PROT_EXEC) { prot = access_mode & (accessmode_RDWR|accessmode_EXEC); } else { if (accessmode_READ & access_mode) { prot = PROT_READ ; } else { prot = PROT_NONE ; } if (accessmode_WRITE & access_mode) { prot |= PROT_WRITE ; } if (accessmode_EXEC & access_mode) { prot |= PROT_EXEC ; } }

Converts accessmode_e into POSIX representation.

#define SETBLACK(     node ) (node)->parent = (redblacktree_node_t*) (((uintptr_t)1) | (uintptr_t)((node)->parent))

Sets the color of node to black.

#define setchild_arraysfmwaybranch(     branch,     childindex,     childnode ) do { (branch)->child[childindex] = (childnode) ; } while(0)

Implements arraysf_mwaybranch_t.setchild_arraysfmwaybranch.

#define setchild_arraystfmwaybranch(     branch,     childindex,     childnode ) do { (branch)->child[childindex] = (childnode) ; } while(0)

Implements arraystf_mwaybranch_t.setchild_arraystfmwaybranch.

#define setcontinue_thread(     is_abort ) ( __extension__ ({ thread_t * _self ; _self = self_thread() ; setreturncode_thread( _self, 0) ; int _err = getcontext( &_self->continuecontext) ; if (_err) { _err = errno ; TRACESYSCALL_ERRLOG( "getcontext", _err) ; } if (returncode_thread( _self)) { *(is_abort) = true ; } else { *(is_abort) = false ; } _err ; }))

Implements thread_t.setcontinue_thread.

#define setcontinuelabel_syncthread(     sthread,     labelname ) ((void)((sthread)->state = __extension__ && labelname))

Implements syncthread_t.setcontinuelabel_syncthread.

#define setcurrent_gcontext(     cont,     disp,     drawsurf,     readsurf ) setcurrent_eglcontext(gl_gcontext(cont), gl_display(disp), gl_surface(drawsurf), gl_surface(readsurf))

Implements gcontext_t.setcurrent_gcontext.

#define setioerror_filereader( frd, ioerr ) ((void)((frd)->ioerror = (ioerr)))

Implements filereader_t.setioerror_filereader.

#define setnegative_bigint(     big ) do { (big)->sign_and_used_digits = (int16_t) ( (big)->sign_and_used_digits < 0 ? (big)->sign_and_used_digits : - (big)->sign_and_used_digits ) ; } while (0)

Implements bigint_t.setnegative_bigint.

#define setnegative_decimal(     dec ) do { (dec)->sign_and_used_digits = (int8_t) ( (dec)->sign_and_used_digits < 0 ? (dec)->sign_and_used_digits : - (dec)->sign_and_used_digits ) ; } while (0)

Implements decimal_t.setnegative_decimal.

#define SETONERROR_testerrortimer(     errtimer,     err ) do { typeof(err) _eret = (err) ; int _err2 ; _err2 = process_testerrortimer(errtimer) ; if (_err2) *_eret = _err2 ; } while(0)

Implements test_errortimer_t.SETONERROR_testerrortimer.

#define SETPARENT(     node,     newparent ) (node)->parent = (redblacktree_node_t*) (COLOR(node) | (uintptr_t)newparent)

Sets the new parent of node and keeps the encoded color.

#define SETPARENTBLACK(     node,     newparent ) (node)->parent = (redblacktree_node_t*) (((uintptr_t)1) | (uintptr_t)newparent)

Sets a new parent for node and sets its color to black.

#define SETPARENTRED( node, newparent ) (node)->parent = newparent

Sets a new parent for node and sets its color to red.

#define setpos_window(     win,     screen_x,     screen_y ) setpos_x11window(os_window(win), screen_x, screen_y)

Implements window_t.setpos_window.

#define SETRED( node ) (node)->parent = PARENT(node)

Sets the color of node to red.

#define setreturncode_thread(     thread,     retcode ) do { volatile typeof(*(thread)) * _thr ; _thr = (thread) ; _thr->returncode = (retcode) ; } while(0)

Implements thread_t.setreturncode_thread.

#define SETSTATE_LOG(     LOGCHANNEL,     LOGSTATE ) log_maincontext().iimpl->setstate(log_maincontext().object, LOGCHANNEL, LOGSTATE)

Sets LOGSTATE for LOGCHANNEL.

#define setstate_syncthread( sthread, state_ ) ((void)((sthread)->state = state_))

Implements syncthread_t.setstate_syncthread.

#define settask_thread(     thread,     _main,     _main_arg ) do { volatile typeof(*(thread)) * _thr ; _thr = (thread) ; _thr->main_task = (_main) ; _thr->main_arg = (_main_arg) ; } while(0)

Implements thread_t.settask_thread.

#define show_window( win ) show_x11window(os_window(win))

Implements window_t.show_window.

#define shrink_wbuffer(     wbuf,     newsize ) ( __extension__ ({ wbuffer_t * _wb = (wbuf) ; _wb->iimpl->shrink(_wb->impl, (newsize), (struct memstream_t*)_wb); }))

Implements wbuffer_t.shrink_wbuffer.

Implements memblock_t.shrinkleft_memblock.

Implements memblock_t.shrinkright_memblock.

Implements bigint_t.sign_bigint.

Implements decimal_t.sign_decimal.

Implements int_t.sign_int as a generic function.

#define signalwait_FREE sys_iochannel_FREE

Static initializer.

#define size_bigint(     big ) ((uint32_t)exponent_bigint(big) + (uint32_t)nrdigits_bigint(big))

Implements bigint_t.size_bigint.

#define size_cstring( cstr ) ((cstr)->size)

Implements cstring_t.size_cstring.

#define size_decimal(     dec ) ((uint8_t)( (dec)->sign_and_used_digits < 0 ? - (dec)->sign_and_used_digits : (dec)->sign_and_used_digits))

Implements decimal_t.size_decimal.

#define size_memblock( mblock ) ((mblock)->size)

Implements memblock_t.size_memblock.

#define size_memstream(     memstr ) ( __extension__ ({ const memstream_t * _m ; _m = (memstr) ; (size_t) (_m->end - _m->next) ; }))

Implements memstream_t.size_memstream.

#define size_mmfile( mfile ) ((mfile)->size)

Implements mmfile_t.size_mmfile.

#define size_pixelbuffer(     pbuf,     disp,     width,     height ) size_eglpbuffer(gl_pixelbuffer(pbuf), gl_display(disp), width, height)

Implements pixelbuffer_t.size_pixelbuffer.

#define size_string( str ) ((str)->size)

Implements string_t.size_string.

#define size_stringstream(     strstream ) ((size_t)((strstream)->end - (strstream)->next))

Implements stringstream_t.size_stringstream.

#define size_threadtls( ) (sys_size_threadtls())

Implements thread_tls_t.size_threadtls.

#define size_vmmappedregions( mappedregions ) ((mappedregions)->total_count)

Returns vm_mappedregions_t->total_count.

#define size_wbuffer(     wbuf ) ( __extension__ ({ const wbuffer_t * _wb = (wbuf) ; _wb->iimpl->size(_wb->impl, (const struct memstream_t*)_wb) ; }))

Implements wbuffer_t.size_wbuffer.

#define size_window( win, width, height ) size_x11window(os_window(win), width, height)

Implements window_t.size_window.

#define size_x11window(     x11win,     width,     height ) (geometry_x11window(x11win, 0, 0, width, height))

Implements x11window_t.size_x11window.

#define SIZE1NODE ( 2*sizeof(trie_node_t*) )

Size of trie_node_t if header_t contains header_SIZE1NODE.

#define SIZE2NODE ( 4*sizeof(trie_node_t*) )

Size of trie_node_t if header_t contains header_SIZE2NODE.

#define SIZE3NODE ( 8*sizeof(trie_node_t*) )

Size of trie_node_t if header_t contains header_SIZE3NODE.

#define SIZE4NODE ( 16*sizeof(trie_node_t*) )

Size of trie_node_t if header_t contains header_SIZE4NODE.

#define SIZE5NODE ( 32*sizeof(trie_node_t*) )

Size of trie_node_t if header_t contains header_SIZE5NODE.

#define sizeallocated_mm( mm ) ((mm).iimpl->sizeallocated((mm).object))

Implements mm_t.sizeallocated_mm.

#define SIZEALLOCATED_MM( ) sizeallocated_mm(mm_maincontext())

REturns number of allocated bytes.

#define sizeallocated_pagecache(     pgcache ) ((pgcache).iimpl->sizeallocated((pgcache).object))

Implements pagecache_t.sizeallocated_pagecache.

#define SIZEALLOCATED_PAGECACHE(     ) (sizeallocated_pagecache(pagecache_maincontext()))

Returns sum of size of all allocated pages.

#define sizebase64encode_string( str ) (4 * ((2 + (str)->size)/3))

Implements string_t.sizebase64encode_string.

#define sizedataprefetch_hwcache( ) (16)

Implements hwcache_t.sizedataprefetch_hwcache.

#define sizefirst_queue(     queue ) ( __extension__ ({ typeof(queue) _qu = (queue) ; size_t _size ; queue_page_t * _first ; if (_qu->last) { _first = (queue_page_t*) ((queue_page_t*)_qu->last)->next ; _size = _first->end_offset - _first->start_offset ; } else { _size = 0 ; } _size ; }))

Implements queue_t.sizefirst_queue.

#define sizefree_logbuffer(     logbuf ) ( __extension__ ({ const logbuffer_t * _lb ; _lb = (logbuf) ; _lb->size - _lb->logsize ; }))

Implements logbuffer_t.sizefree_logbuffer.

#define sizelast_queue(     queue ) ( __extension__ ({ typeof(queue) _qu = (queue) ; size_t _size ; queue_page_t * _last ; if (_qu->last) { _last = (queue_page_t*)_qu->last ; _size = _last->end_offset - _last->start_offset ; } else { _size = 0 ; } _size ; }))

Implements queue_t.sizelast_queue.

#define sizemax_decimal( ) ((uint8_t)127)

Implements decimal_t.sizemax_decimal.

#define SIZEMAXNODE SIZE5NODE

Same as SIZE5NODE.

#define sizeprefix_utf8validator(     utf8validator ) ((utf8validator)->size_of_prefix)

Implements utf8validator_t.sizeprefix_utf8validator.

#define sizereserved_wbuffer(     wbuf ) ( __extension__ ({ const wbuffer_t * _wb2 = (wbuf) ; (size_t) (_wb2->end - _wb2->next) ; }))

Implements wbuffer_t.sizereserved_wbuffer.

#define sizestatic_maincontext( ) (self_maincontext()->size_staticmem)

Inline implementation of maincontext_t.sizestatic_maincontext.

#define sizestatic_pagecache(     pgcache ) ((pgcache).iimpl->sizestatic((pgcache).object))

Implements pagecache_t.sizestatic_pagecache.

#define SIZESTATIC_PAGECACHE( ) (sizestatic_pagecache(pagecache_maincontext()))

Returns size of static allocated memory.

Increments suffixtree_leaf_t.str_start and decrements suffixtree_leaf_t.str_size with _add.

#define skipascii_utf8reader(     utfread ) do { typeof(utfread) _rd1 = (utfread) ; bool _isnext = isnext_utf8reader(_rd1) ; if (_isnext) { incrcolumn_textpos(&_rd1->pos) ; if ('\n' == *(_rd1->next ++)) { incrline_textpos(&_rd1->pos) ; } } } while(0)

Implements utf8reader_t.skipascii_utf8reader.

#define skipbyte_string( str ) do { ++ (str)->addr ; -- (str)->size ; } while(0)

Implements string_t.skipbyte_string.

#define skipbyte_stringstream( strstream ) do { ++ (strstream)->next ; } while(0)

Implements stringstream_t.skipbyte_stringstream.

#define skipbytes_stringstream(     strstream,     size ) do { (strstream)->next += (size) ; } while(0)

Implements stringstream_t.skipbytes_stringstream.

#define skipbytes_utf8reader(     utfread,     nrbytes,     nrchars ) do { typeof(utfread) _rd1 = (utfread) ; size_t _nrb1 = (nrbytes) ; size_t _size = unreadsize_utf8reader(_rd1) ; if (_size >= _nrb1) { _rd1->next += _nrb1 ; addcolumn_textpos(&_rd1->pos,(nrchars)) ; } } while(0)

Implements utf8reader_t.skipbytes_utf8reader.

#define skipchar_utf8reader(     utfread ) ( __extension__ ({ int _err = 0 ; typeof(utfread) _rd1 = (utfread) ; if (isnext_utf8reader(_rd1)) { uint8_t firstbyte = *(_rd1->next) ; if ('\n' == firstbyte) { incrline_textpos(&_rd1->pos) ; ++ _rd1->next ; } else { uint8_t _sz ; _sz = sizefromfirstbyte_utf8( firstbyte) ; if (_sz > (_rd1->end - _rd1->next)) { _err = EILSEQ ; } else { _rd1->next += _sz + (_sz==0) ; incrcolumn_textpos(&_rd1->pos) ; } } } else { _err = ENODATA ; } _err ; }))

Implements utf8reader_t.skipchar_utf8reader.

#define skiputf8_stringstream(     strstream ) ( __extension__ ({ char32_t _uchar ; nextutf8_stringstream( (strstream), &_uchar ) ; }))

Implements stringstream_t.skiputf8_stringstream.

#define slist_IMPLEMENT(     _fsuffix,     object_t,     name_nextptr ) typedef slist_iterator_t iteratortype##_fsuffix ; typedef object_t * iteratedtype##_fsuffix ; static inline int initfirst##_fsuffix##iterator(slist_iterator_t * iter, slist_t * list) __attribute__ ((always_inline)) ; static inline int free##_fsuffix##iterator(slist_iterator_t * iter) __attribute__ ((always_inline)) ; static inline bool next##_fsuffix##iterator(slist_iterator_t * iter, object_t ** node) __attribute__ ((always_inline)) ; static inline void init##_fsuffix(slist_t * list) __attribute__ ((always_inline)) ; static inline int free##_fsuffix(slist_t * list, struct typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int isempty##_fsuffix(const slist_t * list) __attribute__ ((always_inline)) ; static inline object_t * first##_fsuffix(const slist_t * list) __attribute__ ((always_inline)) ; static inline object_t * last##_fsuffix(const slist_t * list) __attribute__ ((always_inline)) ; static inline object_t * next##_fsuffix(object_t * node) __attribute__ ((always_inline)) ; static inline bool isinlist##_fsuffix(object_t * node) __attribute__ ((always_inline)) ; static inline void insertfirst##_fsuffix(slist_t * list, object_t * new_node) __attribute__ ((always_inline)) ; static inline void insertlast##_fsuffix(slist_t * list, object_t * new_node) __attribute__ ((always_inline)) ; static inline void insertafter##_fsuffix(slist_t * list, object_t * prev_node, object_t * new_node) __attribute__ ((always_inline)) ; static inline int removefirst##_fsuffix(slist_t * list, object_t ** removed_node) __attribute__ ((always_inline)) ; static inline int removeafter##_fsuffix(slist_t * list, object_t * prev_node, object_t ** removed_node) __attribute__ ((always_inline)) ; static inline int removeall##_fsuffix(slist_t * list, struct typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline slist_node_t * asnode##_fsuffix(object_t * object) { static_assert(&((object_t*)0)->name_nextptr == (slist_node_t**)offsetof(object_t, name_nextptr), "correct type") ; return (slist_node_t *) ((uintptr_t)object + offsetof(object_t, name_nextptr)) ; } static inline object_t * asobject##_fsuffix(slist_node_t * node) { return (object_t *) ((uintptr_t)node - offsetof(object_t, name_nextptr)) ; } static inline object_t * asobjectnull##_fsuffix(slist_node_t * node) { return node ? (object_t *) ((uintptr_t)node - offsetof(object_t, name_nextptr)) : 0 ; } static inline void init##_fsuffix(slist_t * list) { init_slist(list) ; } static inline void initsingle##_fsuffix(slist_t * list, object_t * node) { initsingle_slist(list, asnode##_fsuffix(node)) ; } static inline int free##_fsuffix(slist_t * list, struct typeadapt_t * typeadp) { return free_slist(list, offsetof(object_t, name_nextptr), typeadp) ; } static inline int isempty##_fsuffix(const slist_t * list) { return isempty_slist(list) ; } static inline object_t * first##_fsuffix(const slist_t * list) { return asobjectnull##_fsuffix(first_slist(list)) ; } static inline object_t * last##_fsuffix(const slist_t * list) { return asobjectnull##_fsuffix(last_slist(list)) ; } static inline object_t * next##_fsuffix(object_t * node) { return asobject##_fsuffix(next_slist(asnode##_fsuffix(node))) ; } static inline bool isinlist##_fsuffix(object_t * node) { return isinlist_slist(asnode##_fsuffix(node)) ; } static inline void insertfirst##_fsuffix(slist_t * list, object_t * new_node) { insertfirst_slist(list, asnode##_fsuffix(new_node)) ; } static inline void insertlast##_fsuffix(slist_t * list, object_t * new_node) { insertlast_slist(list, asnode##_fsuffix(new_node)) ; } static inline void insertafter##_fsuffix(slist_t * list, object_t * prev_node, object_t * new_node) { insertafter_slist(list, asnode##_fsuffix(prev_node), asnode##_fsuffix(new_node)) ; } static inline int removefirst##_fsuffix(slist_t * list, object_t ** removed_node) { int err = removefirst_slist(list, (slist_node_t**)removed_node) ; if (!err) *removed_node = asobject##_fsuffix(*(slist_node_t**)removed_node) ; return err ; } static inline int removeafter##_fsuffix(slist_t * list, object_t * prev_node, object_t ** removed_node) { int err = removeafter_slist(list, asnode##_fsuffix(prev_node), (slist_node_t**)removed_node) ; if (!err) *removed_node = asobject##_fsuffix(*(slist_node_t**)removed_node) ; return err ; } static inline int removeall##_fsuffix(slist_t * list, struct typeadapt_t * typeadp) { return removeall_slist(list, offsetof(object_t, name_nextptr), typeadp) ; } static inline int initfirst##_fsuffix##iterator(slist_iterator_t * iter, slist_t * list) { return initfirst_slistiterator(iter, list) ; } static inline int free##_fsuffix##iterator(slist_iterator_t * iter) { return free_slistiterator(iter) ; } static inline bool next##_fsuffix##iterator(slist_iterator_t * iter, object_t ** node) { bool isNext = next_slistiterator(iter, (slist_node_t**)node) ; if (isNext) *node = asobject##_fsuffix(*(slist_node_t**)node) ; return isNext ; }

Implements slist_t.slist_IMPLEMENT.

void slist_IMPLEMENT( IDNAME  _fsuffix, TYPENAME  object_t, IDNAME  name_nextptr ) ;

Generates interface of single linked list storing elements of type object_t.

Macro generates slist interface FCT_blocklist for pagecache_block_t.

Macro generates slist interface FCT_freeblocklist for pagecache_block_t.

Generates list managing suffixtree_iterator_t -- see slist_IMPLEMENT.

#define slist_INIT { (void*)0 }

Static initializer.

#define slist_iterator_FREE { 0, 0 }

Static initializer.

#define slist_node_EMBED( name_nextptr ) slist_node_t * name_nextptr

Allows to embed members of slist_node_t into another structure.

#define slist_node_INIT { 0 }

Static initializer.

#define slock_mutex( /*mutex_t  * */mutex ) (assert(!lock_mutex(mutex))) ;

Implements mutex_t.slock_mutex.

#define slock_thrmutex( mutex ) (assert(!lock_thrmutex(mutex)))

Implements thrmutex_t.slock_thrmutex.

#define slockreader_rwlock( rwlock ) (assert(!lockreader_rwlock(rwlock)))

Implements rwlock_t.slockreader_rwlock.

#define slockwriter_rwlock( rwlock ) (assert(!lockwriter_rwlock(rwlock)))

Implements rwlock_t.slockwriter_rwlock.

#define splaytree_FREE splaytree_INIT( )

Static initializer: After assigning you can call free_splaytree without harm.

#define splaytree_IMPLEMENT(     _fsuffix,     object_t,     key_t,     nodename ) typedef splaytree_iterator_t iteratortype##_fsuffix ; typedef object_t * iteratedtype##_fsuffix ; static inline int initfirst##_fsuffix##iterator(splaytree_iterator_t * iter, splaytree_t * tree, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int initlast##_fsuffix##iterator(splaytree_iterator_t * iter, splaytree_t * tree, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int free##_fsuffix##iterator(splaytree_iterator_t * iter) __attribute__ ((always_inline)) ; static inline bool next##_fsuffix##iterator(splaytree_iterator_t * iter, object_t ** node) __attribute__ ((always_inline)) ; static inline bool prev##_fsuffix##iterator(splaytree_iterator_t * iter, object_t ** node) __attribute__ ((always_inline)) ; static inline void init##_fsuffix(/*out*/splaytree_t * tree) __attribute__ ((always_inline)) ; static inline int free##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline void getinistate##_fsuffix(const splaytree_t * tree, /*out*/object_t ** root) __attribute__ ((always_inline)) ; static inline bool isempty##_fsuffix(const splaytree_t * tree) __attribute__ ((always_inline)) ; static inline int find##_fsuffix(splaytree_t * tree, const key_t key, /*out*/object_t ** found_node, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int insert##_fsuffix(splaytree_t * tree, object_t * new_node, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int remove##_fsuffix(splaytree_t * tree, object_t * node, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int removenodes##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline int invariant##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) __attribute__ ((always_inline)) ; static inline splaytree_node_t * asnode##_fsuffix(object_t * object) { static_assert(&((object_t*)0)->nodename == (splaytree_node_t*)offsetof(object_t, nodename), "correct type") ; return (splaytree_node_t *) ((uintptr_t)object + offsetof(object_t, nodename)) ; } static inline object_t * asobject##_fsuffix(splaytree_node_t * node) { return (object_t *) ((uintptr_t)node - offsetof(object_t, nodename)) ; } static inline object_t * asobjectnull##_fsuffix(splaytree_node_t * node) { return node ? (object_t *) ((uintptr_t)node - offsetof(object_t, nodename)) : 0 ; } static inline void init##_fsuffix(/*out*/splaytree_t * tree) { init_splaytree(tree) ; } static inline int free##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) { return free_splaytree(tree, offsetof(object_t, nodename), typeadp) ; } static inline void getinistate##_fsuffix(const splaytree_t * tree, /*out*/object_t ** root) { splaytree_node_t * rootnode ; getinistate_splaytree(tree, &rootnode) ; *root = asobjectnull##_fsuffix(rootnode) ; } static inline bool isempty##_fsuffix(const splaytree_t * tree) { return isempty_splaytree(tree) ; } static inline int find##_fsuffix(splaytree_t * tree, const key_t key, /*out*/object_t ** found_node, typeadapt_t * typeadp) { int err = find_splaytree(tree, (void*)key, (splaytree_node_t**)found_node, offsetof(object_t, nodename), typeadp) ; if (err == 0) *found_node = asobject##_fsuffix(*(splaytree_node_t**)found_node) ; return err ; } static inline int insert##_fsuffix(splaytree_t * tree, object_t * new_node, typeadapt_t * typeadp) { return insert_splaytree(tree, asnode##_fsuffix(new_node), offsetof(object_t, nodename), typeadp) ; } static inline int remove##_fsuffix(splaytree_t * tree, object_t * node, typeadapt_t * typeadp) { int err = remove_splaytree(tree, asnode##_fsuffix(node), offsetof(object_t, nodename), typeadp) ; return err ; } static inline int removenodes##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) { return removenodes_splaytree(tree, offsetof(object_t, nodename), typeadp) ; } static inline int invariant##_fsuffix(splaytree_t * tree, typeadapt_t * typeadp) { return invariant_splaytree(tree, offsetof(object_t, nodename), typeadp) ; } static inline int initfirst##_fsuffix##iterator(splaytree_iterator_t * iter, splaytree_t * tree, typeadapt_t * typeadp) { return initfirst_splaytreeiterator(iter, tree, offsetof(object_t, nodename), typeadp) ; } static inline int initlast##_fsuffix##iterator(splaytree_iterator_t * iter, splaytree_t * tree, typeadapt_t * typeadp) { return initlast_splaytreeiterator(iter, tree, offsetof(object_t, nodename), typeadp) ; } static inline int free##_fsuffix##iterator(splaytree_iterator_t * iter) { return free_splaytreeiterator(iter) ; } static inline bool next##_fsuffix##iterator(splaytree_iterator_t * iter, object_t ** node) { bool isNext = next_splaytreeiterator(iter, (splaytree_node_t**)node) ; if (isNext) *node = asobject##_fsuffix(*(splaytree_node_t**)node) ; return isNext ; } static inline bool prev##_fsuffix##iterator(splaytree_iterator_t * iter, object_t ** node) { bool isNext = prev_splaytreeiterator(iter, (splaytree_node_t**)node) ; if (isNext) *node = asobject##_fsuffix(*(splaytree_node_t**)node) ; return isNext ; }

Implements splaytree_t.splaytree_IMPLEMENT.

void splaytree_IMPLEMENT( IDNAME  _fsuffix, TYPENAME  object_t, TYPENAME  key_t, IDNAME  nodename ) ;

Generates interface of splaytree_t storing elements of type object_t.

#define splaytree_INIT( root ) { root }

Static initializer.

#define splaytree_iterator_FREE { 0, 0, 0, 0 }

Static initializer.

#define splitstring_FREE { { string_FREE, string_FREE }, 0 }

Static initializer.

#define state_syncthread( sthread ) ((void*)((sthread)->state))

Implements syncthread_t.state_syncthread.

#define state_x11window( x11win ) ((x11window_state_e)(x11win)->state)

Implements x11window_t.state_x11window.

#define static_assert( C, S ) ((void)(sizeof(char[(C)?1:-1])))

Checks condition to be true during compilation.

#define STR( S1 ) STR2(S1)

Makes string token out of argument.

#define str_cstring( cstr ) ((char*)(cstr)->chars)

Implements cstring_t.str_cstring.

#define str_errorcontext(     errcontext,     errnum ) ( __extension__ ({ unsigned _errnum = (unsigned) (errnum) ; (errcontext).strdata + (errcontext).stroffset[ (_errnum > 511 ? 511 : _errnum)] ; }))

Implements errorcontext_t.str_errorcontext.

#define STR_SIZE( leaf ) ((leaf)->str_size >> 1)

Returns the size of the string this node or leaf matches.

#define STR_START( leaf ) ((leaf)->str_start)

Returns the start address of the string this node or leaf matches.

#define STR2( S1 ) # S1

Used by STR to ensure expansion of arguments.

#define string_field_INIT_EMPTY { string_field_EMPTY, { 0 } }

Static initializer.

#define string_FREE { 0, 0 }

Static initializer.

#define string_INIT( strsize, straddr ) { (straddr), (strsize) }

Static initializer.

#define string_INIT_CSTR( cstr ) { (const uint8_t*)(cstr), strlen(cstr) }

Static initializer.

#define stringcast_arraystfnode(     str ) ( __extension__ ({ struct string_t * _str1 = (str) ; (arraystf_node_t*) (_str1) ; }))

Implements arraystf_node_t.stringcast_arraystfnode.

#define stringstream_FREE stringstream_INIT( 0, )

Static initializer.

#define stringstream_INIT( startaddr, endaddr ) { startaddr, endaddr }

Static initializer.

#define STRPARAM_filepathstatic( fpath ) (fpath)->workdir, (fpath)->filename

Implements filepath_static_t.STRPARAM_filepathstatic.

#define structof(     struct_t,     member,     ptrmember ) ( __extension__ ({ typeof(((struct_t*)0)->member) * _ptr2 ; _ptr2 = (ptrmember) ; (struct_t*) ((uintptr_t)_ptr2 - offsetof(struct_t, member)) ; }))

Converts pointer to member of structure to pointer of containing structure.

#define suffixtree_addstate_INIT(     strsize,     straddr ) { suffixtree_pos_INIT, string_INIT(strsize,straddr) }

Static initializer.

#define suffixtree_FREE { (void*)0, 0 }

Static initializer.

#define suffixtree_leaf_EMBED() suffixtree_node_t * next_child ; const uint8_t * str_start ; size_t str_size

Allows to embed all data fields of suffixtree_leaf_t into another structure.

#define suffixtree_pos_INIT { 0, NULL, NULL }

Static initializer.

#define sunlock_mutex( /*mutex_t  * */mutex ) (assert(!unlock_mutex(mutex))) ;

Implements mutex_t.sunlock_mutex.

#define sunlock_thrmutex( mutex ) (assert(!unlock_thrmutex(mutex)))

Implements thrmutex_t.sunlock_thrmutex.

#define sunlockreader_rwlock( rwlock ) (assert(!unlockreader_rwlock(rwlock)))

Implements rwlock_t.sunlockreader_rwlock.

#define sunlockwriter_rwlock( rwlock ) (assert(!unlockwriter_rwlock(rwlock)))

Implements rwlock_t.sunlockwriter_rwlock.

#define surface_EMBED struct opengl_surface_t * glsurface

Inherits from surface_t by embedding all data fields.

#define surface_FREE { 0 }

Static initializer.

#define surface_FREE_EMBEDDED 0

Static initializer for types which inherit from surface_t with surface_EMBED.

#define SWAP(     var1,     var2 ) { typeof(var1) _temp ; _temp = (var1), (var1) = (var2), (var2) = _temp ; }

Swaps content of two local variables.

#define syncevent_FREE { 0 }

Static initializer.

#define syncevent_INIT( waiting ) { waiting }

Static initializer.

#define syncqueue_FREE syncqueue_INIT

Static initializer.

#define syncqueue_INIT { 0, 0 }

Static initializer.

#define syncrun_FREE { { syncqueue_FREE }, syncwlist_FREE, { 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }

Static initializer.

#define syncrun_maincontext( ) (tcontext_maincontext()->syncrun)

Inline implementation of maincontext_t.syncrun_maincontext.

#define syncthread_FREE { 0, 0 }

Static initializer.

#define syncthread_INIT( mainfct, state ) { mainfct, state }

Static initializer.

#define syncwait_FREE { syncthread_FREE, 0, 0 }

Static initializer.

#define syncwlist_FREE { 0, 0, 0 }

Static initializer.

#define syncwlist_iterator_FREE { 0, 0 }

Static initializer.

#define sys_context_threadtls(     ) ( __extension__ ({ int _addr ; sys_context2_threadtls( &_addr) ; }))

Implements thread_tls_t.sys_context_threadtls.

#define sys_context2_threadtls(     local_var ) (threadcontext_t*) ( (uintptr_t)(local_var) & ~(uintptr_t) (sys_size_threadtls()-1) )

Implements thread_tls_t.sys_context2_threadtls.

#define sys_iochannel_FREE ( -1 )

Choose Posix file descriptor type.

#define sys_iochannel_STDERR STDERR_FILENO

Choose Posix STDERR file descriptor number.

#define sys_iochannel_STDIN STDIN_FILENO

Choose Posix STDIN file descriptor number.

#define sys_iochannel_STDOUT STDOUT_FILENO

Choose Posix STDOUT file descriptor number.

#define sys_iochannel_t int

Choose Posix file descriptor type.

#define sys_mutex_INIT_DEFAULT PTHREAD_MUTEX_INITIALIZER

Static initializer for sys_mutex_t.

#define sys_mutex_t pthread_mutex_t

Chooses Posix mutex type.

#define sys_path_MAXSIZE PATH_MAX

The maximum size in bytes of a file system path.

#define sys_process_FREE ( )

Static initializer for sys_process_t.

#define sys_process_t pid_t

Chooses Posix process id.

#define sys_semaphore_FREE ( -1 )

Static initializer for sys_semaphore_t.

#define sys_semaphore_t int

Chooses Posix semaphore handle.

#define sys_size_threadtls( ) (512*1024)

Implements thread_tls_t.sys_size_threadtls.

#define sys_socketaddr_MAXSIZE sizeof( struct  sockaddr_in6 )

Defined as Posix specific size of IPv6 addresses.

#define sys_socketaddr_t struct sockaddr

Chooses Posix socket address type.

#define sys_sqroot_int64 sqrtl

Replaces sqroot_int64 with faster sqrtl (long double version).

#define sys_thread_FREE ( )

Static initializer for sys_thread_t.

#define sys_thread_t pthread_t

Chooses Posix thread type.

#define sys_thread_threadtls( ) ((thread_t*)(&sys_context_threadtls()[1]))

Implements thread_tls_t.sys_thread_threadtls.

#define sys_userid_FREE ( (uid_t)(-1) )

Static initializer for sys_userid_t.

#define sys_userid_t uid_t

Chooses Posix system user id.

#define systimer_FREE sys_iochannel_FREE

Static initializer.

#define sysuser_FREE { sysuser_id_FREE, sysuser_id_FREE, sysuser_id_FREE }

Static initializer.

#define sysuser_id_FREE sys_userid_FREE

Static initializer.

#define sysuser_maincontext( ) (pcontext_maincontext()->sysuser)

Inline implementation of maincontext_t.sysuser_maincontext.

#define sysuser_SYS_SERVICE_NAME "passwd"

The name of service used during authentication.

#define sysuser_UNITTEST_PASSWORD "GUEST"

Used in unittest_platform_sysuser to test switchtoprivilege_sysuser.

#define sysuser_UNITTEST_USERNAME "guest"

Used in unittest_platform_sysuser to test switchtoprivilege_sysuser.