Hosted by the courtesy of  
 GitHub  		The stars ASAP english francais spanish arab
Durée du voyage intersidéral francais
Résolutions de l'ONU en HTML francais
Bussard Ramjet english francais
 DWARF : dwarf2xml english
ELF : libelf examples english
Code presentation : ctoohtml english

To rings Doc++

File Index

All Tags

Tags by File

Tags referrers

Cross reference index

macro : EXCP_MOD

  File Line   Context
exception.h20#ifndef EXCP_MOD
exception_errno.h15      errno = (EXCP_MOD) | (error_no); \
exception_errno.h31      (errno = (EXCP_MOD) | (error_no));\
exception_stderr.h29      (errno = (EXCP_MOD) | (error_no));\
exception_stderr.h9      errno = (EXCP_MOD) | (error_no); \

macro : RING_ALLOC_BLK_CHK

  File Line   Context
ring_alloc.c217#ifdef RING_ALLOC_BLK_CHK
ring_alloc.c23#if defined(RING_ALLOC_BLK_CHK) || defined(RING_ALLOC_POOL_CHK)
ring_alloc.c31#ifdef RING_ALLOC_BLK_CHK
ring_alloc.c32  #undef RING_ALLOC_BLK_CHK
ring_alloc.c37#ifdef RING_ALLOC_BLK_CHK
ring_alloc.c42#ifdef RING_ALLOC_BLK_CHK
ring_alloc.c72#ifdef RING_ALLOC_BLK_CHK
ring_alloc.c74   blk->chk_1[0] = rotate(RING_ALLOC_BLK_CHK,1) ; \
ring_alloc.c75   blk->chk_1[1] = rotate(RING_ALLOC_BLK_CHK,2) ; \
ring_alloc.c76   blk->chk_2[0] = rotate(RING_ALLOC_BLK_CHK,3) ; \
ring_alloc.c77   blk->chk_2[1] = rotate(RING_ALLOC_BLK_CHK,4) ; \
ring_alloc.c89   assert( blk->chk_1[0] == rotate(RING_ALLOC_BLK_CHK,1) );
ring_alloc.c90   assert( blk->chk_1[1] == rotate(RING_ALLOC_BLK_CHK,2) );
ring_alloc.c91   assert( blk->chk_2[0] == rotate(RING_ALLOC_BLK_CHK,3) );
ring_alloc.c92   assert( blk->chk_2[1] == rotate(RING_ALLOC_BLK_CHK,4) );

macro : RING_ALLOC_POOL_CHK

  File Line   Context
ring_alloc.c131#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c138   assert( mempool->chk_1 == rotate(RING_ALLOC_POOL_CHK,1) );
ring_alloc.c139   assert( mempool->chk_2 == rotate(RING_ALLOC_POOL_CHK,2) );
ring_alloc.c140   assert( mempool->chk_3 == rotate(RING_ALLOC_POOL_CHK,3) );
ring_alloc.c141   assert( mempool->chk_4 == rotate(RING_ALLOC_POOL_CHK,4) );
ring_alloc.c142   assert( mempool->chk_5 == rotate(RING_ALLOC_POOL_CHK,5) );
ring_alloc.c185#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c186   pool->chk_1 = rotate(RING_ALLOC_POOL_CHK,1);
ring_alloc.c187   pool->chk_2 = rotate(RING_ALLOC_POOL_CHK,2);
ring_alloc.c188   pool->chk_3 = rotate(RING_ALLOC_POOL_CHK,3);
ring_alloc.c189   pool->chk_4 = rotate(RING_ALLOC_POOL_CHK,4);
ring_alloc.c190   pool->chk_5 = rotate(RING_ALLOC_POOL_CHK,5);
ring_alloc.c214#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c23#if defined(RING_ALLOC_BLK_CHK) || defined(RING_ALLOC_POOL_CHK)
ring_alloc.c27#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c28  #undef RING_ALLOC_POOL_CHK
ring_alloc.c47#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c51#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c57#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c61#ifdef RING_ALLOC_POOL_CHK
ring_alloc.c65#ifdef RING_ALLOC_POOL_CHK

macro : RING_ALLOC_RELEASE

  File Line   Context
ring_alloc.c207   info->release = RING_ALLOC_RELEASE;

macro : RING_ALLOC_STATS

  File Line   Context
ring_alloc.c144#ifdef RING_ALLOC_STATS
ring_alloc.c159#ifdef RING_ALLOC_STATS
ring_alloc.c168#ifdef RING_ALLOC_STATS
ring_alloc.c198#ifdef RING_ALLOC_STATS
ring_alloc.c211#ifdef RING_ALLOC_STATS
ring_alloc.c225#ifdef RING_ALLOC_STATS
ring_alloc.c259#else /* RING_ALLOC_STATS */
ring_alloc.c268#endif /* RING_ALLOC_STATS */
ring_alloc.c54#ifdef RING_ALLOC_STATS

macro : RING_ALLOC_VERSION

  File Line   Context
ring_alloc.c206   info->version = RING_ALLOC_VERSION;

macro : _EXCEPTION_H_

  File Line   Context
exception.h24#endif /* ] _EXCEPTION_H_ */
exception.h7#ifndef _EXCEPTION_H_ /* [ */

macro : _RING_ALLOC_H_

  File Line   Context
ring_alloc.h11#ifndef _RING_ALLOC_H_ /* [ */
ring_alloc.h44#endif /* ] _RING_ALLOC_H_ */

macro : _RING_H_

  File Line   Context
ring.h15#ifndef _RING_H_ /* [ */
ring.h379#endif /* ] _RING_H_ */

variable : check_opt

  File Line   Context
ring.c115   if ( check_opt > 0 && !f_ring_selftest(node, offset) == 0) excp_relay (return 0, "Memory jam");
ring.c161   if ( check_opt > 0 && !f_nring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c179   if ( check_opt > 0 && !f_nring_selftest(ring, offset) == 0) excp_relay (return 0, " ");
ring.c203   if ( check_opt > 0 && !f_nring_selftest(ring, offset) == 0 ) excp_relay (return 0, "Memory jam");
ring.c208   if ( check_opt > 0 && f_nring_is_in(new, ring, offset) ) 
ring.c232   if ( check_opt > 0 && !f_nring_selftest(node, offset) == 0) excp_relay (return 0, "Memory jam");
ring.c284   if ( check_opt > 0 && !f_dring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c308   if ( check_opt > 0 && !f_dring_selftest(ring, offset) ) excp_relay (return 0, " ") ;
ring.c32int f_ring_check_opt(int level) { if ( level != -1 ) check_opt = level; return check_opt; }
ring.c32int f_ring_check_opt(int level) { if ( level != -1 ) check_opt = level; return check_opt; }
ring.c334   if ( check_opt > 0 && !f_dring_selftest(ring, offset) == 0 ) excp_relay (return 0, " ");
ring.c336   if ( check_opt > 0 && f_dring_is_in(new, ring, offset) ) 
ring.c361   if ( check_opt > 0 && !f_dring_selftest(node, offset) == 0) excp_relay (return 0, " ");
ring.c412   if ( check_opt > 0 && !f_ndring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c437   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) ) excp_relay (return 0, " ") ;
ring.c460   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) == 0) excp_relay (return 0, " ");
ring.c484   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) == 0 ) excp_relay (return 0, " ");
ring.c488   if ( check_opt > 0 && f_ndring_is_in(new, ring, offset) ) 
ring.c515   if ( check_opt > 0 && !f_ndring_selftest(node, offset) == 0) excp_relay (return 0, " ");
ring.c69   if ( check_opt > 0 && !f_ring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c90   if ( check_opt > 0 && !f_ring_selftest(ring, offset) == 0 ) excp_relay (return 0, "Memory jam");
ring.c93   if ( check_opt > 0 && f_ring_is_in(new, ring, offset) ) 
ring.h70 *  These macros call the same routine that is it used when check_opt is set.

macro : excp_assert

  File Line   Context
exception_errno.h26#ifdef excp_assert
exception_errno.h27  #undef excp_assert
exception_stderr.h24#ifdef excp_assert
exception_stderr.h25  #undef excp_assert

function : f_dring_is_in

  File Line   Context
ring.c336   if ( check_opt > 0 && f_dring_is_in(new, ring, offset) ) 
ring.h108#define m_dring_is_in(is, in, field) (f_dring_is_in(&((is)->field), &((in)->field), offsetof(typeof(*(in)), field) ) )
ring.h330bool f_dring_is_in(struct s_dring *is, struct s_dring *in, size_t offset);

function : f_dring_link

  File Line   Context
ring.h134#define m_dring_link(p_ring, field, node) ( (typeof(p_ring))f_dring_link(&((p_ring)->field), &((node)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h340void *f_dring_link(struct s_dring *ring, struct s_dring *_new, size_t offset);
ring.h364struct s_dring *f_dring_link(struct s_dring *ring, struct s_dring *new);

function : f_dring_move

  File Line   Context
ring.h277   (typeof(p_ring))f_dring_move(&((p_ring)->field), hops, check, offsetof(typeof(*(p_ring)), field) ) )
ring.h346void *f_dring_move(struct s_dring *ring, int hops, bool check, size_t offset);
ring.h362struct s_dring *f_dring_move(struct s_dring *ring, int hops, bool check);

function : f_dring_selftest

  File Line   Context
ring.c284   if ( check_opt > 0 && !f_dring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c308   if ( check_opt > 0 && !f_dring_selftest(ring, offset) ) excp_relay (return 0, " ") ;
ring.c334   if ( check_opt > 0 && !f_dring_selftest(ring, offset) == 0 ) excp_relay (return 0, " ");
ring.c361   if ( check_opt > 0 && !f_dring_selftest(node, offset) == 0) excp_relay (return 0, " ");
ring.h324bool f_dring_selftest(struct s_dring *ring, size_t offset);
ring.h86   (typeof(p_ring))f_dring_selftest(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )

function : f_dring_test

  File Line   Context
ring_test.c394   f_dring_test();

function : f_dring_unlink

  File Line   Context
ring.h157#define m_dring_unlink(p_ring, field) ( (typeof(p_ring))f_dring_unlink(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h335void *f_dring_unlink(struct s_dring *node, size_t offset);
ring.h365struct s_dring *f_dring_unlink(struct s_dring *node);

function : f_mempool_calloc

  File Line   Context
ring_alloc.h42void *f_mempool_calloc(to_mempool mempool, size_t nmemb, size_t size);

function : f_mempool_check

  File Line   Context
ring_alloc.c228   f_mempool_check(mempool);
ring_alloc.c274   f_mempool_check(mempool);
ring_alloc.c302   f_mempool_check(mempool);
ring_alloc.c310   f_mempool_check(mempool);
ring_alloc.c346   f_mempool_check(mempool);

macro : f_mempool_check_blk

  File Line   Context
ring_alloc.c155       assert( f_mempool_check_blk(mempool, mempool->free, blk) );
ring_alloc.c164       assert( f_mempool_check_blk(mempool, mempool->alloc, blk) );

function : f_mempool_free

  File Line   Context
ring_alloc.c387   if ( f_mempool_free(mempool, mem) < 0 ) return 0;
ring_alloc.h38int f_mempool_free(to_mempool mempool, void *mem);
ring_alloc_test.c35   assert( !f_mempool_free(mempool, mem[1]) );
ring_alloc_test.c36   assert( !f_mempool_free(mempool, mem[3]) );
ring_alloc_test.c37   assert( !f_mempool_free(mempool, mem[5]) );
ring_alloc_test.c38   assert( !f_mempool_free(mempool, mem[0]) );
ring_alloc_test.c39   assert( !f_mempool_free(mempool, mem[2]) );
ring_alloc_test.c40   assert( !f_mempool_free(mempool, mem[4]) );
ring_alloc_test.c55   assert( f_mempool_free(mempool, (void *)0x30) == -1 && errno == ENOTDIR);
ring_alloc_test.c56   errno = 0; assert( !f_mempool_free(mempool, 0) && errno == 0);
ring_alloc_test.c57   assert( !f_mempool_free(mempool, mem) );
ring_alloc_test.c58   assert( f_mempool_free(mempool, mem) == -1 && errno == ENOENT);

function : f_mempool_info

  File Line   Context
ring_alloc.h27int f_mempool_info(struct s_mempool_info *info);
ring_alloc_test.c29   assert ( !f_mempool_info(&info) );
ring_alloc_test.c46   assert ( !f_mempool_info(&info) );

function : f_mempool_init

  File Line   Context
ring_alloc.h19to_mempool f_mempool_init(size_t size, void *start);
ring_alloc_test.c31   assert( (mempool = f_mempool_init(size, region)) ) ;
ring_alloc_test.c42   assert( !(mempool = f_mempool_init(0, region)) && errno == ENOMEM) ;
ring_alloc_test.c43   assert( !(mempool = f_mempool_init(16, region)) && errno == ENOMEM) ;
ring_alloc_test.c44   assert( !(mempool = f_mempool_init(200, 0)) && errno == EFAULT) ;
ring_alloc_test.c51   assert( !(mempool = f_mempool_init(info.pool_head_size +info.block_head_size -1, region)) && errno == ENOMEM) ;
ring_alloc_test.c52   assert( (mempool = f_mempool_init(info.pool_head_size +info.block_head_size, region)) ) ;

function : f_mempool_malloc

  File Line   Context
ring_alloc.c354   if ( !mem ) return f_mempool_malloc(mempool, size);
ring_alloc.c385   if ( !(umem = f_mempool_malloc(mempool, size)) ) return 0;
ring_alloc.c394   if ( !(mem = f_mempool_malloc(mempool, nmemb*size)) == 0) return 0;
ring_alloc.h36void *f_mempool_malloc(to_mempool mempool, size_t size);
ring_alloc_test.c33      assert( (mem[i] = f_mempool_malloc(mempool, 40)) );
ring_alloc_test.c54   assert( (mem = f_mempool_malloc(mempool, 0)) );

function : f_mempool_realloc

  File Line   Context
ring_alloc.h40void *f_mempool_realloc(to_mempool mempool, void *mem, size_t size);

function : f_mempool_stats

  File Line   Context
ring_alloc.h34int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats);
ring_alloc_test.c53   assert( f_mempool_stats(mempool, &stats) == 0 ) ;

function : f_ndring_find

  File Line   Context
ring.c490   if ( f_ndring_find(ring, new->name, offset) ) 
ring.h248   (typeof(p_ring))f_ndring_find(&((p_ring)->field), (name), offsetof(typeof(*(p_ring)), field) ) )
ring.h344void *f_ndring_find(struct s_ndring *ring, const char *name, size_t offset);

function : f_ndring_is_in

  File Line   Context
ring.c488   if ( check_opt > 0 && f_ndring_is_in(new, ring, offset) ) 
ring.h110#define m_ndring_is_in(is, in, field) (f_ndring_is_in(&((is)->field), &((in)->field), offsetof(typeof(*(in)), field) ) )
ring.h331bool f_ndring_is_in(struct s_ndring *is, struct s_ndring *in, size_t offset);

function : f_ndring_link

  File Line   Context
ring.h136#define m_ndring_link(p_ring, field, node) ( (typeof(p_ring))f_ndring_link(&((p_ring)->field), &((node)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h341void *f_ndring_link(struct s_ndring *ring, struct s_ndring *_new, size_t offset);

function : f_ndring_move

  File Line   Context
ring.h280   (typeof(p_ring))f_ndring_move(&((p_ring)->field), hops, check, offsetof(typeof(*(p_ring)), field) ) )
ring.h347void *f_ndring_move(struct s_ndring *ring, int hops, bool check, size_t offset);

function : f_ndring_selftest

  File Line   Context
ring.c412   if ( check_opt > 0 && !f_ndring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c437   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) ) excp_relay (return 0, " ") ;
ring.c460   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) == 0) excp_relay (return 0, " ");
ring.c484   if ( check_opt > 0 && !f_ndring_selftest(ring, offset) == 0 ) excp_relay (return 0, " ");
ring.c515   if ( check_opt > 0 && !f_ndring_selftest(node, offset) == 0) excp_relay (return 0, " ");
ring.h326bool f_ndring_selftest(struct s_ndring *ring, size_t offset);
ring.h89   (typeof(p_ring))f_ndring_selftest(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )

function : f_ndring_test

  File Line   Context
ring_test.c395   f_ndring_test();

function : f_ndring_unlink

  File Line   Context
ring.h159#define m_ndring_unlink(p_ring, field) ( (typeof(p_ring))f_ndring_unlink(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h336void *f_ndring_unlink(struct s_ndring *node, size_t offset);

function : f_nring_find

  File Line   Context
ring.c210   if ( f_nring_find(ring, new->name, offset) ) 
ring.h245   (typeof(p_ring))f_nring_find(&((p_ring)->field), (name), offsetof(typeof(*(p_ring)), field) ) )
ring.h343void *f_nring_find(struct s_nring *ring, const char *name, size_t offset);
ring.h358struct s_nring *f_nring_find(struct s_nring *ring, const char *name);

function : f_nring_is_in

  File Line   Context
ring.c208   if ( check_opt > 0 && f_nring_is_in(new, ring, offset) ) 
ring.h106#define m_nring_is_in(is, in, field) (f_nring_is_in(&((is)->field), &((in)->field), offsetof(typeof(*(in)), field) ) )
ring.h329bool f_nring_is_in(struct s_nring *is, struct s_nring *in, size_t offset);

function : f_nring_link

  File Line   Context
ring.h132#define m_nring_link(p_ring, field, node) ( (typeof(p_ring))f_nring_link(&((p_ring)->field), &((node)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h339void *f_nring_link(struct s_nring *ring, struct s_nring *_new, size_t offset);
ring.h356struct s_nring *f_nring_link(struct s_nring *ring, struct s_nring *new);

function : f_nring_selftest

  File Line   Context
ring.c161   if ( check_opt > 0 && !f_nring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c179   if ( check_opt > 0 && !f_nring_selftest(ring, offset) == 0) excp_relay (return 0, " ");
ring.c203   if ( check_opt > 0 && !f_nring_selftest(ring, offset) == 0 ) excp_relay (return 0, "Memory jam");
ring.c232   if ( check_opt > 0 && !f_nring_selftest(node, offset) == 0) excp_relay (return 0, "Memory jam");
ring.h325bool f_nring_selftest(struct s_nring *ring, size_t offset);
ring.h83   (typeof(p_ring))f_nring_selftest(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )

function : f_nring_test

  File Line   Context
ring_test.c393   f_nring_test();

function : f_nring_unlink

  File Line   Context
ring.h155#define m_nring_unlink(p_ring, field) ( (typeof(p_ring))f_nring_unlink(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h334void *f_nring_unlink(struct s_nring *node, size_t offset);
ring.h357struct s_nring *f_nring_unlink(struct s_nring *node);

function : f_ring_check_opt

  File Line   Context
ring.h311int f_ring_check_opt(int level);
ring_test.c391   f_ring_check_opt(1);

function : f_ring_is_in

  File Line   Context
ring.c93   if ( check_opt > 0 && f_ring_is_in(new, ring, offset) ) 
ring.h104#define m_ring_is_in(is, in, field)  (f_ring_is_in(&((is)->field), &((in)->field), offsetof(typeof(*(in)), field) ) )
ring.h328bool f_ring_is_in(struct s_ring *is, struct s_ring *in, size_t offset);

function : f_ring_link

  File Line   Context
ring.h130#define m_ring_link(p_ring, field, node) ( (typeof(p_ring))f_ring_link(&((p_ring)->field), &((node)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h338void *f_ring_link(struct s_ring *ring, struct s_ring *_new, size_t offset);
ring.h352struct s_ring *f_ring_link(struct s_ring *ring, struct s_ring *node);

function : f_ring_selftest

  File Line   Context
ring.c115   if ( check_opt > 0 && !f_ring_selftest(node, offset) == 0) excp_relay (return 0, "Memory jam");
ring.c69   if ( check_opt > 0 && !f_ring_selftest(in, offset) ) excp_relay (return 0, " ") ;
ring.c90   if ( check_opt > 0 && !f_ring_selftest(ring, offset) == 0 ) excp_relay (return 0, "Memory jam");
ring.h323bool f_ring_selftest(struct s_ring *ring, size_t offset);
ring.h80   (typeof(p_ring))f_ring_selftest(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )

function : f_ring_test

  File Line   Context
ring_test.c392   f_ring_test();

function : f_ring_unlink

  File Line   Context
ring.h153#define m_ring_unlink(p_ring, field) ( (typeof(p_ring))f_ring_unlink(&((p_ring)->field), offsetof(typeof(*(p_ring)), field) ) )
ring.h333void *f_ring_unlink(struct s_ring *node, size_t offset);
ring.h353struct s_ring *f_ring_unlink(struct s_ring *node);

macro : m_blk_setup

  File Line   Context
ring_alloc.c197   m_blk_setup(pool->free);
ring_alloc.c294      m_blk_setup(best);

macro : m_dring_do

  File Line   Context
ring_test.c226   m_dring_do(list, node) {

macro : m_dring_done

  File Line   Context
ring_test.c232   } m_dring_done(list, node, link);

macro : m_dring_is_in

  File Line   Context
ring_test.c206      assert( m_dring_is_in(&elem[i], list, link) );
ring_test.c207      assert( m_dring_is_in(m_dring_next(&elem[i], link), list, link) );
ring_test.c208      assert( m_dring_is_in(m_dring_prev(&elem[i], link), list, link) );
ring_test.c209      assert( m_dring_is_in(m_dring_move(&elem[i], 3, 1, link), list, link) );
ring_test.c210      assert( m_dring_is_in(m_dring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c211      assert( m_dring_is_in(m_dring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c212      assert(!m_dring_is_in(m_dring_move(&elem[i],-4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c213      assert(!m_dring_is_in(m_dring_move(&elem[i], 4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c245   assert( !m_dring_is_in(&out, list, link) );
ring_test.c246   assert( !m_dring_is_in(&out, (struct s_dring_test *)0, link) && errno == 0); errno = 0;
ring_test.c247   assert( !m_dring_is_in((struct s_dring_test *)0, list, link) && errno == EFAULT); errno = 0;
ring_test.c250   assert ( m_dring_is_in(&elem[0], list, link) );
ring_test.c251   assert ( m_dring_is_in(&elem[1], list, link) );
ring_test.c252   assert ( m_dring_is_in(&elem[2], list, link) );
ring_test.c253   assert (!m_dring_is_in(&elem[3], list, link) );
ring_test.c255   assert ( m_dring_is_in(&elem[0], list, link) );
ring_test.c256   assert (!m_dring_is_in(&elem[1], list, link) );
ring_test.c257   assert ( m_dring_is_in(&elem[2], list, link) );
ring_test.c258   assert (!m_dring_is_in(&elem[3], list, link) );
ring_test.c260   assert ( m_dring_is_in(&elem[0], list, link) );
ring_test.c261   assert (!m_dring_is_in(&elem[1], list, link) );
ring_test.c262   assert ( m_dring_is_in(&elem[2], list, link) );
ring_test.c263   assert ( m_dring_is_in(&elem[3], list, link) );
ring_test.c265   assert (!m_dring_is_in(&elem[0], list, link) );
ring_test.c266   assert (!m_dring_is_in(&elem[1], list, link) );
ring_test.c267   assert ( m_dring_is_in(&elem[3], list, link) );
ring_test.c268   assert ( m_dring_is_in(&elem[2], list, link) );
ring_test.c270   assert (!m_dring_is_in(&elem[0], list, link) );
ring_test.c271   assert (!m_dring_is_in(&elem[1], list, link) );
ring_test.c272   assert (!m_dring_is_in(&elem[2], list, link) );
ring_test.c273   assert ( m_dring_is_in(&elem[3], list, link) );
ring_test.c275   assert (!m_dring_is_in(&elem[0], list, link) );
ring_test.c276   assert (!m_dring_is_in(&elem[1], list, link) );
ring_test.c277   assert (!m_dring_is_in(&elem[2], list, link) );
ring_test.c278   assert (!m_dring_is_in(&elem[3], list, link) );

macro : m_dring_link

  File Line   Context
ring_test.c196   assert ( (list = m_dring_link(list, link, &elem[0])) );
ring_test.c197   assert ( !(list = m_dring_link(list, link, &elem[0])) && errno == EEXIST); errno = 0;
ring_test.c201      assert(list = m_dring_link(list, link, &elem[i]) );
ring_test.c259   assert (list = m_dring_link(list, link, &elem[3]) );

macro : m_dring_list

  File Line   Context
ring_test.c236   for ( node = list; node; node = m_dring_list(list, node, link) ) {

macro : m_dring_move

  File Line   Context
ring_test.c209      assert( m_dring_is_in(m_dring_move(&elem[i], 3, 1, link), list, link) );
ring_test.c210      assert( m_dring_is_in(m_dring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c211      assert( m_dring_is_in(m_dring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c212      assert(!m_dring_is_in(m_dring_move(&elem[i],-4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c213      assert(!m_dring_is_in(m_dring_move(&elem[i], 4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c215//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_dring_move(&elem[i],-1, 1, link), m_dring_prev(&elem[i], link), m_dring_next(&elem[i], link));
ring_test.c217      assert( m_dring_move(&elem[i], 4, 0, link) == &elem[i]);
ring_test.c218      assert( m_dring_move(&elem[i],-4, 0, link) == &elem[i]);
ring_test.c219      assert( m_dring_move(&elem[i], 0, 1, link) == &elem[i] );
ring_test.c220      assert( m_dring_move(&elem[i],-1, 1, link) == m_dring_prev(&elem[i], link) );
ring_test.c221      assert( m_dring_move(&elem[i], 1, 1, link) == m_dring_next(&elem[i], link) );

macro : m_dring_next

  File Line   Context
ring.h200#define m_dring_list(ring, node, field) ( (((node) = m_dring_next(node, field)) == (ring))?0:(node) )
ring.h227#define m_dring_done(ring, var, field) while ( (var) = m_dring_next((var), field), (var) != (ring) )
ring_test.c207      assert( m_dring_is_in(m_dring_next(&elem[i], link), list, link) );
ring_test.c215//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_dring_move(&elem[i],-1, 1, link), m_dring_prev(&elem[i], link), m_dring_next(&elem[i], link));
ring_test.c221      assert( m_dring_move(&elem[i], 1, 1, link) == m_dring_next(&elem[i], link) );
ring_test.c222      assert( m_dring_prev(m_dring_next(&elem[i], link), link) == &elem[i] );
ring_test.c223      assert( m_dring_next(m_dring_prev(&elem[i], link), link) == &elem[i] );

macro : m_dring_prev

  File Line   Context
ring_test.c208      assert( m_dring_is_in(m_dring_prev(&elem[i], link), list, link) );
ring_test.c215//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_dring_move(&elem[i],-1, 1, link), m_dring_prev(&elem[i], link), m_dring_next(&elem[i], link));
ring_test.c220      assert( m_dring_move(&elem[i],-1, 1, link) == m_dring_prev(&elem[i], link) );
ring_test.c222      assert( m_dring_prev(m_dring_next(&elem[i], link), link) == &elem[i] );
ring_test.c223      assert( m_dring_next(m_dring_prev(&elem[i], link), link) == &elem[i] );

macro : m_dring_selftest

  File Line   Context
ring_test.c202      assert( m_dring_selftest(list, link) );

macro : m_dring_unlink

  File Line   Context
ring_test.c249   assert( (list = m_dring_unlink(&elem[3], link)) && errno == 0); 
ring_test.c254   assert( (list = m_dring_unlink(&elem[1], link)) && errno == 0); 
ring_test.c264   assert( (list = m_dring_unlink(&elem[0], link)) && errno == 0); 
ring_test.c269   assert( (list = m_dring_unlink(&elem[2], link)) && errno == 0); 
ring_test.c274   assert( !(list = m_dring_unlink(&elem[3], link)) && errno == 0); 

macro : m_mempool_stats_alloc

  File Line   Context
ring_alloc.c301   m_mempool_stats_alloc(mempool, best->size, split);

macro : m_mempool_stats_free

  File Line   Context
ring_alloc.c345   m_mempool_stats_free(mempool, size, cat);

macro : m_ndring_do

  File Line   Context
ring_test.c335   m_ndring_do(list, node) {

macro : m_ndring_done

  File Line   Context
ring_test.c341   } m_ndring_done(list, node, link);

macro : m_ndring_find

  File Line   Context
ring_test.c315      assert( m_ndring_find(list, link, names[i]) == &elem[i] );

macro : m_ndring_is_in

  File Line   Context
ring_test.c314      assert( m_ndring_is_in(&elem[i], list, link) );
ring_test.c316      assert( m_ndring_is_in(m_ndring_next(&elem[i], link), list, link) );
ring_test.c317      assert( m_ndring_is_in(m_ndring_prev(&elem[i], link), list, link) );
ring_test.c318      assert( m_ndring_is_in(m_ndring_move(&elem[i], 3, 1, link), list, link) );
ring_test.c319      assert( m_ndring_is_in(m_ndring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c320      assert( m_ndring_is_in(m_ndring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c321      assert(!m_ndring_is_in(m_ndring_move(&elem[i],-4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c322      assert(!m_ndring_is_in(m_ndring_move(&elem[i], 4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c354   assert( !m_ndring_is_in(&out, list, link) );
ring_test.c355   assert( !m_ndring_is_in(&out, (struct s_ndring_test *)0, link) && errno == 0); errno = 0;
ring_test.c356   assert( !m_ndring_is_in((struct s_ndring_test *)0, list, link) && errno == EFAULT); errno = 0;
ring_test.c359   assert ( m_ndring_is_in(&elem[0], list, link) );
ring_test.c360   assert ( m_ndring_is_in(&elem[1], list, link) );
ring_test.c361   assert ( m_ndring_is_in(&elem[2], list, link) );
ring_test.c362   assert (!m_ndring_is_in(&elem[3], list, link) );
ring_test.c364   assert ( m_ndring_is_in(&elem[0], list, link) );
ring_test.c365   assert (!m_ndring_is_in(&elem[1], list, link) );
ring_test.c366   assert ( m_ndring_is_in(&elem[2], list, link) );
ring_test.c367   assert (!m_ndring_is_in(&elem[3], list, link) );
ring_test.c369   assert ( m_ndring_is_in(&elem[0], list, link) );
ring_test.c370   assert (!m_ndring_is_in(&elem[1], list, link) );
ring_test.c371   assert ( m_ndring_is_in(&elem[2], list, link) );
ring_test.c372   assert ( m_ndring_is_in(&elem[3], list, link) );
ring_test.c374   assert (!m_ndring_is_in(&elem[0], list, link) );
ring_test.c375   assert (!m_ndring_is_in(&elem[1], list, link) );
ring_test.c376   assert ( m_ndring_is_in(&elem[3], list, link) );
ring_test.c377   assert ( m_ndring_is_in(&elem[2], list, link) );
ring_test.c379   assert (!m_ndring_is_in(&elem[0], list, link) );
ring_test.c380   assert (!m_ndring_is_in(&elem[1], list, link) );
ring_test.c381   assert (!m_ndring_is_in(&elem[2], list, link) );
ring_test.c382   assert ( m_ndring_is_in(&elem[3], list, link) );
ring_test.c384   assert (!m_ndring_is_in(&elem[0], list, link) );
ring_test.c385   assert (!m_ndring_is_in(&elem[1], list, link) );
ring_test.c386   assert (!m_ndring_is_in(&elem[2], list, link) );
ring_test.c387   assert (!m_ndring_is_in(&elem[3], list, link) );

macro : m_ndring_link

  File Line   Context
ring_test.c291   assert ( (list = m_ndring_link(list, link, &elem[0])) );
ring_test.c293   assert ( !(list = m_ndring_link(list, link, &elem[1])) && errno == ENOTUNIQ); errno = 0;
ring_test.c296   assert ( (list = m_ndring_link(list, link, &elem[0])) );
ring_test.c297   assert ( !(list = m_ndring_link(list, link, &elem[0])) && errno == EEXIST); errno = 0;
ring_test.c304   assert ( (list = m_ndring_link(list, link, &elem[0])) );
ring_test.c305   assert ( !(list = m_ndring_link(list, link, &elem[0])) && errno == EEXIST); errno = 0;
ring_test.c309      assert(list = m_ndring_link(list, link, &elem[i]) );
ring_test.c368   assert (list = m_ndring_link(list, link, &elem[3]) );

macro : m_ndring_list

  File Line   Context
ring_test.c345   for ( node = list; node; node = m_ndring_list(list, node, link) ) {

macro : m_ndring_move

  File Line   Context
ring_test.c318      assert( m_ndring_is_in(m_ndring_move(&elem[i], 3, 1, link), list, link) );
ring_test.c319      assert( m_ndring_is_in(m_ndring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c320      assert( m_ndring_is_in(m_ndring_move(&elem[i],-3, 1, link), list, link) );
ring_test.c321      assert(!m_ndring_is_in(m_ndring_move(&elem[i],-4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c322      assert(!m_ndring_is_in(m_ndring_move(&elem[i], 4, 1, link), list, link) && errno == ELOOP); errno = 0;
ring_test.c324//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_ndring_move(&elem[i],-1, 1, link), m_ndring_prev(&elem[i], link), m_ndring_next(&elem[i], link));
ring_test.c326      assert( m_ndring_move(&elem[i], 4, 0, link) == &elem[i]);
ring_test.c327      assert( m_ndring_move(&elem[i],-4, 0, link) == &elem[i]);
ring_test.c328      assert( m_ndring_move(&elem[i], 0, 1, link) == &elem[i] );
ring_test.c329      assert( m_ndring_move(&elem[i],-1, 1, link) == m_ndring_prev(&elem[i], link) );
ring_test.c330      assert( m_ndring_move(&elem[i], 1, 1, link) == m_ndring_next(&elem[i], link) );

macro : m_ndring_next

  File Line   Context
ring.h202#define m_ndring_list(ring, node, field) ( (((node) = m_ndring_next(node, field)) == (ring))?0:(node) )
ring.h231#define m_ndring_done(ring, var, field) while ( (var) = m_ndring_next((var), field), (var) != (ring) )
ring_test.c316      assert( m_ndring_is_in(m_ndring_next(&elem[i], link), list, link) );
ring_test.c324//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_ndring_move(&elem[i],-1, 1, link), m_ndring_prev(&elem[i], link), m_ndring_next(&elem[i], link));
ring_test.c330      assert( m_ndring_move(&elem[i], 1, 1, link) == m_ndring_next(&elem[i], link) );
ring_test.c331      assert( m_ndring_prev(m_ndring_next(&elem[i], link), link) == &elem[i] );
ring_test.c332      assert( m_ndring_next(m_ndring_prev(&elem[i], link), link) == &elem[i] );

macro : m_ndring_prev

  File Line   Context
ring_test.c317      assert( m_ndring_is_in(m_ndring_prev(&elem[i], link), list, link) );
ring_test.c324//printf("node : %08x, move -1 : %08x, prev : %08x, next : %08x\n", &elem[i], m_ndring_move(&elem[i],-1, 1, link), m_ndring_prev(&elem[i], link), m_ndring_next(&elem[i], link));
ring_test.c329      assert( m_ndring_move(&elem[i],-1, 1, link) == m_ndring_prev(&elem[i], link) );
ring_test.c331      assert( m_ndring_prev(m_ndring_next(&elem[i], link), link) == &elem[i] );
ring_test.c332      assert( m_ndring_next(m_ndring_prev(&elem[i], link), link) == &elem[i] );

macro : m_ndring_selftest

  File Line   Context
ring_test.c310      assert( m_ndring_selftest(list, link) );

macro : m_ndring_unlink

  File Line   Context
ring_test.c358   assert( (list = m_ndring_unlink(&elem[3], link)) && errno == 0); 
ring_test.c363   assert( (list = m_ndring_unlink(&elem[1], link)) && errno == 0); 
ring_test.c373   assert( (list = m_ndring_unlink(&elem[0], link)) && errno == 0); 
ring_test.c378   assert( (list = m_ndring_unlink(&elem[2], link)) && errno == 0); 
ring_test.c383   assert( !(list = m_ndring_unlink(&elem[3], link)) && errno == 0); 

macro : m_nring_do

  File Line   Context
ring_test.c132   m_nring_do(list, node) {

macro : m_nring_done

  File Line   Context
ring_test.c138   } m_nring_done(list, node, link);

macro : m_nring_find

  File Line   Context
ring_test.c129      assert( m_nring_find(list, link, names[i]) == &elem[i] );

macro : m_nring_is_in

  File Line   Context
ring_test.c127      assert( m_nring_is_in(&elem[i], list, link) );
ring_test.c128      assert( m_nring_is_in(m_nring_next(&elem[i], link), list, link) );
ring_test.c151   assert( !m_nring_is_in(&out, list, link) );
ring_test.c152   assert( !m_nring_is_in(&out, (struct s_nring_test *)0, link) && errno == 0); errno = 0;
ring_test.c153   assert( !m_nring_is_in((struct s_nring_test *)0, list, link) && errno == EFAULT); errno = 0;
ring_test.c156   assert ( m_nring_is_in(&elem[0], list, link) );
ring_test.c157   assert ( m_nring_is_in(&elem[1], list, link) );
ring_test.c158   assert ( m_nring_is_in(&elem[2], list, link) );
ring_test.c159   assert (!m_nring_is_in(&elem[3], list, link) );
ring_test.c161   assert ( m_nring_is_in(&elem[0], list, link) );
ring_test.c162   assert (!m_nring_is_in(&elem[1], list, link) );
ring_test.c163   assert ( m_nring_is_in(&elem[2], list, link) );
ring_test.c164   assert (!m_nring_is_in(&elem[3], list, link) );
ring_test.c166   assert ( m_nring_is_in(&elem[0], list, link) );
ring_test.c167   assert (!m_nring_is_in(&elem[1], list, link) );
ring_test.c168   assert ( m_nring_is_in(&elem[2], list, link) );
ring_test.c169   assert ( m_nring_is_in(&elem[3], list, link) );
ring_test.c171   assert (!m_nring_is_in(&elem[0], list, link) );
ring_test.c172   assert (!m_nring_is_in(&elem[1], list, link) );
ring_test.c173   assert ( m_nring_is_in(&elem[3], list, link) );
ring_test.c174   assert ( m_nring_is_in(&elem[2], list, link) );
ring_test.c176   assert (!m_nring_is_in(&elem[0], list, link) );
ring_test.c177   assert (!m_nring_is_in(&elem[1], list, link) );
ring_test.c178   assert (!m_nring_is_in(&elem[2], list, link) );
ring_test.c179   assert ( m_nring_is_in(&elem[3], list, link) );
ring_test.c181   assert (!m_nring_is_in(&elem[0], list, link) );
ring_test.c182   assert (!m_nring_is_in(&elem[1], list, link) );
ring_test.c183   assert (!m_nring_is_in(&elem[2], list, link) );
ring_test.c184   assert (!m_nring_is_in(&elem[3], list, link) );

macro : m_nring_link

  File Line   Context
ring_test.c109   assert ( (list = m_nring_link(list, link, &elem[0])) );
ring_test.c111   assert ( !(list = m_nring_link(list, link, &elem[1])) && errno == ENOTUNIQ); errno = 0;
ring_test.c114   assert ( (list = m_nring_link(list, link, &elem[0])) );
ring_test.c115   assert ( !(list = m_nring_link(list, link, &elem[0])) && errno == EEXIST); errno = 0;
ring_test.c123      assert(list = m_nring_link(list, link, &elem[i]) );
ring_test.c165   assert (list = m_nring_link(list, link, &elem[3]) );

macro : m_nring_list

  File Line   Context
ring_test.c142   for ( node = list; node; node = m_nring_list(list, node, link) ) {

macro : m_nring_next

  File Line   Context
ring.h198#define m_nring_list(ring, node, field) ( (((node) = m_nring_next(node, field)) == (ring))?0:(node) )
ring.h223#define m_nring_done(ring, var, field) while ( (var) = m_nring_next((var), field), (var) != (ring) )
ring_test.c128      assert( m_nring_is_in(m_nring_next(&elem[i], link), list, link) );

macro : m_nring_selftest

  File Line   Context
ring_test.c124      assert( m_nring_selftest(list, link) );

macro : m_nring_unlink

  File Line   Context
ring_test.c155   assert( (list = m_nring_unlink(&elem[3], link)) && errno == 0); 
ring_test.c160   assert( (list = m_nring_unlink(&elem[1], link)) && errno == 0); 
ring_test.c170   assert( (list = m_nring_unlink(&elem[0], link)) && errno == 0); 
ring_test.c175   assert( (list = m_nring_unlink(&elem[2], link)) && errno == 0); 
ring_test.c180   assert( !(list = m_nring_unlink(&elem[3], link)) && errno == 0); 

macro : m_ring_do

  File Line   Context
ring_test.c44   m_ring_do(list, node) {

macro : m_ring_done

  File Line   Context
ring.h208 *  <pre>m_ring_do(ring, node) ++i; m_ring_done(ring, node, field);</pre>
ring_test.c50   } m_ring_done(list, node, link);

macro : m_ring_is_in

  File Line   Context
ring_alloc.c320   if ( !m_ring_is_in(umem, mempool->alloc, brother) ) {
ring_alloc.c94   assert ( m_ring_is_in(blk, list, brother) );
ring_alloc.c96   // assert ( (m_ring_is_in(blk, pool->free, brother) ^ m_ring_is_in(blk, pool->alloc, brother)) );
ring_alloc.c96   // assert ( (m_ring_is_in(blk, pool->free, brother) ^ m_ring_is_in(blk, pool->alloc, brother)) );
ring_alloc.c97   neibourgs += m_ring_is_in(blk, pool->alloc, brother);
ring_alloc.c98   neibourgs += 2*m_ring_is_in(blk, pool->free, brother);
ring_test.c40      assert( m_ring_is_in(&elem[i], list, link) );
ring_test.c41      assert( m_ring_is_in(m_ring_next(&elem[i], link), list, link) );
ring_test.c63   assert( !m_ring_is_in(&out, list, link) );
ring_test.c64   assert( !m_ring_is_in(&out, (struct s_ring_test *)0, link) && errno == 0); errno = 0;
ring_test.c65   assert( !m_ring_is_in((struct s_ring_test *)0, list, link) && errno == EFAULT); errno = 0;
ring_test.c68   assert ( m_ring_is_in(&elem[0], list, link) );
ring_test.c69   assert ( m_ring_is_in(&elem[1], list, link) );
ring_test.c70   assert ( m_ring_is_in(&elem[2], list, link) );
ring_test.c71   assert (!m_ring_is_in(&elem[3], list, link) );
ring_test.c73   assert ( m_ring_is_in(&elem[0], list, link) );
ring_test.c74   assert (!m_ring_is_in(&elem[1], list, link) );
ring_test.c75   assert ( m_ring_is_in(&elem[2], list, link) );
ring_test.c76   assert (!m_ring_is_in(&elem[3], list, link) );
ring_test.c78   assert ( m_ring_is_in(&elem[0], list, link) );
ring_test.c79   assert (!m_ring_is_in(&elem[1], list, link) );
ring_test.c80   assert ( m_ring_is_in(&elem[2], list, link) );
ring_test.c81   assert ( m_ring_is_in(&elem[3], list, link) );
ring_test.c83   assert (!m_ring_is_in(&elem[0], list, link) );
ring_test.c84   assert (!m_ring_is_in(&elem[1], list, link) );
ring_test.c85   assert ( m_ring_is_in(&elem[3], list, link) );
ring_test.c86   assert ( m_ring_is_in(&elem[2], list, link) );
ring_test.c88   assert (!m_ring_is_in(&elem[0], list, link) );
ring_test.c89   assert (!m_ring_is_in(&elem[1], list, link) );
ring_test.c90   assert (!m_ring_is_in(&elem[2], list, link) );
ring_test.c91   assert ( m_ring_is_in(&elem[3], list, link) );
ring_test.c93   assert (!m_ring_is_in(&elem[0], list, link) );
ring_test.c94   assert (!m_ring_is_in(&elem[1], list, link) );
ring_test.c95   assert (!m_ring_is_in(&elem[2], list, link) );
ring_test.c96   assert (!m_ring_is_in(&elem[3], list, link) );

macro : m_ring_link

  File Line   Context
ring.h117 * <pre>ring_ptr = m_ring_link(ring_ptr, field, node);</pre>
ring_alloc.c195   pool->free = m_ring_link(pool->free, brother, pool->mem);
ring_alloc.c295      mempool->alloc = m_ring_link(mempool->alloc, brother, best);
ring_alloc.c299      mempool->alloc = m_ring_link(mempool->alloc, brother, best);
ring_alloc.c343   mempool->free = m_ring_link(mempool->free, brother, umem);
ring_alloc.c376            mempool->alloc = m_ring_link(mempool->alloc, brother, umem);
ring_alloc.c380            mempool->alloc = m_ring_link(mempool->alloc, brother, umem);
ring_test.c30   assert ( (list = m_ring_link(list, link, &elem[0])) );
ring_test.c31   assert ( !(list = m_ring_link(list, link, &elem[0])) && errno == EEXIST); errno = 0;
ring_test.c35      assert(list = m_ring_link(list, link, &elem[i]) );
ring_test.c77   assert (list = m_ring_link(list, link, &elem[3]) );

macro : m_ring_list

  File Line   Context
ring.h188 *     for (node = ring; !node; node = m_ring_list(list, node, brother) ) { ... }
ring_alloc.c104   for (mem = pool->alloc; mem; mem = m_ring_list(pool->alloc, mem, brother)) {
ring_alloc.c111   for (mem = pool->free; mem; mem = m_ring_list(pool->free, mem, brother) ) {
ring_alloc.c154   for (blk = mempool->free; blk; blk = m_ring_list(mempool->free, blk, brother)) {
ring_alloc.c163   for (blk = mempool->alloc; blk; blk = m_ring_list(mempool->alloc, blk, brother)) {
ring_alloc.c278   for (blk = mempool->free; blk; blk = m_ring_list(mempool->free, blk, brother)) {
ring_alloc.c326   for (blk = mempool->free; blk; blk = m_ring_list(mempool->free, blk, brother)) {
ring_alloc.c335   for (blk = mempool->free; blk; blk = m_ring_list(mempool->free, blk, brother)) {
ring_alloc.c363   for (blk = mempool->free; blk; blk = m_ring_list(mempool->free, blk, brother)) {
ring_test.c54   for ( node = list; node; node = m_ring_list(list, node, link) ) {

macro : m_ring_next

  File Line   Context
ring.h196#define m_ring_list(ring, node, field) ( (((node) = m_ring_next(node, field)) == (ring))?0:(node) )
ring.h219#define m_ring_done(ring, var, field) while ( (var) = m_ring_next((var), field), (var) != (ring) )
ring_test.c41      assert( m_ring_is_in(m_ring_next(&elem[i], link), list, link) );

macro : m_ring_selftest

  File Line   Context
ring_test.c36      assert( m_ring_selftest(list, link) );

macro : m_ring_unlink

  File Line   Context
ring.h143 *  <pre>ring_ptr = m_ring_unlink(node, field);</pre>
ring_alloc.c298      mempool->free = m_ring_unlink(best, brother);
ring_alloc.c324   mempool->alloc = m_ring_unlink(umem, brother);
ring_alloc.c329         mempool->free = m_ring_unlink(blk, brother);
ring_alloc.c365         mempool->free = m_ring_unlink(blk, brother);
ring_alloc.c379            mempool->free = m_ring_unlink(umem, brother);
ring_test.c67   assert( (list = m_ring_unlink(&elem[3], link)) && errno == 0); 
ring_test.c72   assert( (list = m_ring_unlink(&elem[1], link)) && errno == 0); 
ring_test.c82   assert( (list = m_ring_unlink(&elem[0], link)) && errno == 0); 
ring_test.c87   assert( (list = m_ring_unlink(&elem[2], link)) && errno == 0); 
ring_test.c92   assert( !(list = m_ring_unlink(&elem[3], link)) && errno == 0); 

macro : raise

  File Line   Context
exception_errno.h10#ifdef raise
exception_errno.h11  #undef raise
exception_stderr.h4#ifdef raise
exception_stderr.h5  #undef raise
ring.h287 *  It is possible to customise error signaling by rewriting raise and relay macros

variable : region

  File Line   Context
ring_alloc_test.c31   assert( (mempool = f_mempool_init(size, region)) ) ;
ring_alloc_test.c42   assert( !(mempool = f_mempool_init(0, region)) && errno == ENOMEM) ;
ring_alloc_test.c43   assert( !(mempool = f_mempool_init(16, region)) && errno == ENOMEM) ;
ring_alloc_test.c51   assert( !(mempool = f_mempool_init(info.pool_head_size +info.block_head_size -1, region)) && errno == ENOMEM) ;
ring_alloc_test.c52   assert( (mempool = f_mempool_init(info.pool_head_size +info.block_head_size, region)) ) ;

macro : relay

  File Line   Context
exception_errno.h19#ifdef relay
exception_errno.h20  #undef relay
exception_stderr.h15#ifdef relay
exception_stderr.h16  #undef relay
ring.h287 *  It is possible to customise error signaling by rewriting raise and relay macros

macro : rotate

  File Line   Context
ring_alloc.c138   assert( mempool->chk_1 == rotate(RING_ALLOC_POOL_CHK,1) );
ring_alloc.c139   assert( mempool->chk_2 == rotate(RING_ALLOC_POOL_CHK,2) );
ring_alloc.c140   assert( mempool->chk_3 == rotate(RING_ALLOC_POOL_CHK,3) );
ring_alloc.c141   assert( mempool->chk_4 == rotate(RING_ALLOC_POOL_CHK,4) );
ring_alloc.c142   assert( mempool->chk_5 == rotate(RING_ALLOC_POOL_CHK,5) );
ring_alloc.c186   pool->chk_1 = rotate(RING_ALLOC_POOL_CHK,1);
ring_alloc.c187   pool->chk_2 = rotate(RING_ALLOC_POOL_CHK,2);
ring_alloc.c188   pool->chk_3 = rotate(RING_ALLOC_POOL_CHK,3);
ring_alloc.c189   pool->chk_4 = rotate(RING_ALLOC_POOL_CHK,4);
ring_alloc.c190   pool->chk_5 = rotate(RING_ALLOC_POOL_CHK,5);
ring_alloc.c74   blk->chk_1[0] = rotate(RING_ALLOC_BLK_CHK,1) ; \
ring_alloc.c75   blk->chk_1[1] = rotate(RING_ALLOC_BLK_CHK,2) ; \
ring_alloc.c76   blk->chk_2[0] = rotate(RING_ALLOC_BLK_CHK,3) ; \
ring_alloc.c77   blk->chk_2[1] = rotate(RING_ALLOC_BLK_CHK,4) ; \
ring_alloc.c89   assert( blk->chk_1[0] == rotate(RING_ALLOC_BLK_CHK,1) );
ring_alloc.c90   assert( blk->chk_1[1] == rotate(RING_ALLOC_BLK_CHK,2) );
ring_alloc.c91   assert( blk->chk_2[0] == rotate(RING_ALLOC_BLK_CHK,3) );
ring_alloc.c92   assert( blk->chk_2[1] == rotate(RING_ALLOC_BLK_CHK,4) );

struct : s_blk

  File Line   Context
ring_alloc.c102//   printf("\nblk   (%08x <-> %08x)\n",  blk,  ((char *)blk + blk->size + sizeof(struct s_blk)) );
ring_alloc.c105//      printf("alloc (%08x <-> %08x)\n",  mem,  ((char *)mem + mem->size + sizeof(struct s_blk)) );
ring_alloc.c107      if ( ((char *)mem + mem->size + sizeof(struct s_blk)) == (char *)blk ) neibourgs |= 1;
ring_alloc.c109      if ( ((char *)blk + blk->size + sizeof(struct s_blk)) == (char *)mem ) neibourgs |= 2;
ring_alloc.c112//      printf("free  (%08x <-> %08x)\n",  mem,  ((char *)mem + mem->size + sizeof(struct s_blk)) );
ring_alloc.c114      if ( ((char *)mem + mem->size + sizeof(struct s_blk)) == (char *)blk ) neibourgs |= 1;
ring_alloc.c116      if ( ((char *)blk + blk->size + sizeof(struct s_blk)) == (char *)mem ) neibourgs |= 2;
ring_alloc.c120   if ( ((char *)blk + blk->size + sizeof(struct s_blk)) == ((char *)pool->mem + pool->size - sizeof(struct s_mempool)) ) neibourgs |= 2;
ring_alloc.c135   struct s_blk *blk = mempool->free;
ring_alloc.c147   assert( (sizeof(struct s_blk) * (
ring_alloc.c172   assert( (sizeof(struct s_blk) * (b_count_a + b_count_f) + o_count_a + o_count_f)
ring_alloc.c183   if ( size < sizeof(struct s_mempool) + sizeof(struct s_blk)) { errno = ENOMEM; return 0; }
ring_alloc.c196   pool->free->size = pool->size -sizeof(struct s_mempool) -sizeof(struct s_blk) ;
ring_alloc.c221   info->block_head_size = sizeof(struct s_blk);
ring_alloc.c245      mempool->stats.instant.bytes.free -= sizeof(struct s_blk); \
ring_alloc.c251   mempool->stats.instant.bytes.free += (size) + (nb_cat)*sizeof(struct s_blk); \
ring_alloc.c272   struct s_blk *blk = mempool->free, *best = 0;
ring_alloc.c286   if ( sizeof(struct s_blk) < best->size - size ) {
ring_alloc.c289      best->size -= (sizeof(struct s_blk) + size);
ring_alloc.c291      best = (struct s_blk *)((char *)best + sizeof(struct s_blk) + best->size);
ring_alloc.c291      best = (struct s_blk *)((char *)best + sizeof(struct s_blk) + best->size);
ring_alloc.c307   struct s_blk *blk = mempool->free;
ring_alloc.c308   struct s_blk *umem = (typeof(blk))mem -1;
ring_alloc.c314      ((char *)mempool->mem + mempool->size) <= ((char *)umem + sizeof(struct s_blk) + umem->size) ) {
ring_alloc.c328      if ( ((char *)umem + umem->size + sizeof(struct s_blk)) == (char *)blk ) {
ring_alloc.c330         umem->size += blk->size + sizeof(struct s_blk);
ring_alloc.c337      if ( ((char *)blk + blk->size + sizeof(struct s_blk)) == (char *)umem ) {
ring_alloc.c338         blk->size += umem->size + sizeof(struct s_blk);
ring_alloc.c351   struct s_blk *blk = mempool->free;
ring_alloc.c352   struct s_blk *umem = (typeof(blk))mem -1;
ring_alloc.c356      ((char *)mempool->mem + mempool->size) <= ((char *)umem + sizeof(struct s_blk) + umem->size) ) {
ring_alloc.c364      if ( ((char *)umem + umem->size + sizeof(struct s_blk)) == (char *)blk ) {
ring_alloc.c366         umem->size += blk->size + sizeof(struct s_blk);
ring_alloc.c368         if ( sizeof(struct s_blk) < umem->size - size ) {
ring_alloc.c371            umem->size -= sizeof(struct s_blk) + size;
ring_alloc.c373            umem = (struct s_blk *)((char *)umem + sizeof(struct s_blk) + size);
ring_alloc.c373            umem = (struct s_blk *)((char *)umem + sizeof(struct s_blk) + size);
ring_alloc.c60   struct s_blk *alloc;
ring_alloc.c64   struct s_blk *free;
ring_alloc.c68   struct s_blk mem[0];
ring_alloc.c80int f_mempool_check_blk(struct s_mempool *pool, struct s_blk *list, struct s_blk *blk) {
ring_alloc.c80int f_mempool_check_blk(struct s_mempool *pool, struct s_blk *list, struct s_blk *blk) {
ring_alloc.c81   struct s_blk *mem;
ring_alloc.c87   assert( ((char *)blk + sizeof(struct s_blk) + blk->size) < ((char *)pool->mem + pool->size) );

struct : s_dring

  File Line   Context
ring.c256bool f_dring_selftest(struct s_dring *ring, size_t offset) {
ring.c280bool f_dring_is_in(struct s_dring *is, struct s_dring *in, size_t offset) {
ring.c280bool f_dring_is_in(struct s_dring *is, struct s_dring *in, size_t offset) {
ring.c304void *f_dring_move(struct s_dring *ring, int hops, bool check, size_t offset) {
ring.c333void *f_dring_link(struct s_dring *ring, struct s_dring *new, size_t offset) {
ring.c333void *f_dring_link(struct s_dring *ring, struct s_dring *new, size_t offset) {
ring.c356void *f_dring_unlink(struct s_dring *node, size_t offset) {
ring.h324bool f_dring_selftest(struct s_dring *ring, size_t offset);
ring.h330bool f_dring_is_in(struct s_dring *is, struct s_dring *in, size_t offset);
ring.h330bool f_dring_is_in(struct s_dring *is, struct s_dring *in, size_t offset);
ring.h335void *f_dring_unlink(struct s_dring *node, size_t offset);
ring.h340void *f_dring_link(struct s_dring *ring, struct s_dring *_new, size_t offset);
ring.h340void *f_dring_link(struct s_dring *ring, struct s_dring *_new, size_t offset);
ring.h346void *f_dring_move(struct s_dring *ring, int hops, bool check, size_t offset);
ring.h360struct s_dring *f_dring_next(struct s_dring *ring);
ring.h360struct s_dring *f_dring_next(struct s_dring *ring);
ring.h361struct s_dring *f_dring_prev(struct s_dring *ring);
ring.h361struct s_dring *f_dring_prev(struct s_dring *ring);
ring.h362struct s_dring *f_dring_move(struct s_dring *ring, int hops, bool check);
ring.h362struct s_dring *f_dring_move(struct s_dring *ring, int hops, bool check);
ring.h364struct s_dring *f_dring_link(struct s_dring *ring, struct s_dring *new);
ring.h364struct s_dring *f_dring_link(struct s_dring *ring, struct s_dring *new);
ring.h364struct s_dring *f_dring_link(struct s_dring *ring, struct s_dring *new);
ring.h365struct s_dring *f_dring_unlink(struct s_dring *node);
ring.h365struct s_dring *f_dring_unlink(struct s_dring *node);
ring_test.c191      struct s_dring link;

struct : s_mempool

  File Line   Context
ring_alloc.c103//   printf("pool  (%08x <-> %08x)\n",  pool->mem,  ((char *)pool->mem + pool->size - sizeof(struct s_mempool)) );
ring_alloc.c120   if ( ((char *)blk + blk->size + sizeof(struct s_blk)) == ((char *)pool->mem + pool->size - sizeof(struct s_mempool)) ) neibourgs |= 2;
ring_alloc.c132int f_mempool_check(struct s_mempool *mempool) {
ring_alloc.c152            == (mempool->size - sizeof(struct s_mempool)) );
ring_alloc.c173           == (mempool->size - sizeof(struct s_mempool)) );
ring_alloc.c181   struct s_mempool *pool = (typeof(pool))(start);
ring_alloc.c183   if ( size < sizeof(struct s_mempool) + sizeof(struct s_blk)) { errno = ENOMEM; return 0; }
ring_alloc.c184   memset(pool, 0, sizeof(struct s_mempool));
ring_alloc.c196   pool->free->size = pool->size -sizeof(struct s_mempool) -sizeof(struct s_blk) ;
ring_alloc.c220   info->pool_head_size = sizeof(struct s_mempool); /* gcc bug ? */
ring_alloc.c80int f_mempool_check_blk(struct s_mempool *pool, struct s_blk *list, struct s_blk *blk) {
ring_alloc.h17typedef struct s_mempool *to_mempool;

struct : s_mempool_info

  File Line   Context
ring_alloc.c204int f_mempool_info(struct s_mempool_info *info) {
ring_alloc.h27int f_mempool_info(struct s_mempool_info *info);
ring_alloc_test.c22   struct s_mempool_info info;

struct : s_mempool_stats

  File Line   Context
ring_alloc.c227int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats) {
ring_alloc.c261int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats) {
ring_alloc.c55   struct s_mempool_stats stats;
ring_alloc.h34int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats);
ring_alloc_test.c23   struct s_mempool_stats stats;

struct : s_ndring

  File Line   Context
ring.c384bool f_ndring_selftest(struct s_ndring *ring, size_t offset) {
ring.c408bool f_ndring_is_in(struct s_ndring *is, struct s_ndring *in, size_t offset) {
ring.c408bool f_ndring_is_in(struct s_ndring *is, struct s_ndring *in, size_t offset) {
ring.c433void *f_ndring_move(struct s_ndring *ring, int hops, bool check, size_t offset) {
ring.c458void *f_ndring_find(struct s_ndring *ring, const char *name, size_t offset) {
ring.c483void *f_ndring_link(struct s_ndring *ring, struct s_ndring *new, size_t offset) {
ring.c483void *f_ndring_link(struct s_ndring *ring, struct s_ndring *new, size_t offset) {
ring.c511void *f_ndring_unlink(struct s_ndring *node, size_t offset) {
ring.h326bool f_ndring_selftest(struct s_ndring *ring, size_t offset);
ring.h331bool f_ndring_is_in(struct s_ndring *is, struct s_ndring *in, size_t offset);
ring.h331bool f_ndring_is_in(struct s_ndring *is, struct s_ndring *in, size_t offset);
ring.h336void *f_ndring_unlink(struct s_ndring *node, size_t offset);
ring.h341void *f_ndring_link(struct s_ndring *ring, struct s_ndring *_new, size_t offset);
ring.h341void *f_ndring_link(struct s_ndring *ring, struct s_ndring *_new, size_t offset);
ring.h344void *f_ndring_find(struct s_ndring *ring, const char *name, size_t offset);
ring.h347void *f_ndring_move(struct s_ndring *ring, int hops, bool check, size_t offset);
ring_test.c284      struct s_ndring link;

struct : s_nring

  File Line   Context
ring.c139bool f_nring_selftest(struct s_nring *ring, size_t offset) {
ring.c157bool f_nring_is_in(struct s_nring *is, struct s_nring *in, size_t offset) {
ring.c157bool f_nring_is_in(struct s_nring *is, struct s_nring *in, size_t offset) {
ring.c177void *f_nring_find(struct s_nring *ring, const char *name, size_t offset) {
ring.c202void *f_nring_link(struct s_nring *ring, struct s_nring *new, size_t offset) {
ring.c202void *f_nring_link(struct s_nring *ring, struct s_nring *new, size_t offset) {
ring.c229void *f_nring_unlink(struct s_nring *node, size_t offset) {
ring.h325bool f_nring_selftest(struct s_nring *ring, size_t offset);
ring.h329bool f_nring_is_in(struct s_nring *is, struct s_nring *in, size_t offset);
ring.h329bool f_nring_is_in(struct s_nring *is, struct s_nring *in, size_t offset);
ring.h334void *f_nring_unlink(struct s_nring *node, size_t offset);
ring.h339void *f_nring_link(struct s_nring *ring, struct s_nring *_new, size_t offset);
ring.h339void *f_nring_link(struct s_nring *ring, struct s_nring *_new, size_t offset);
ring.h343void *f_nring_find(struct s_nring *ring, const char *name, size_t offset);
ring.h355struct s_nring *f_nring_next(struct s_nring *ring);
ring.h355struct s_nring *f_nring_next(struct s_nring *ring);
ring.h356struct s_nring *f_nring_link(struct s_nring *ring, struct s_nring *new);
ring.h356struct s_nring *f_nring_link(struct s_nring *ring, struct s_nring *new);
ring.h356struct s_nring *f_nring_link(struct s_nring *ring, struct s_nring *new);
ring.h357struct s_nring *f_nring_unlink(struct s_nring *node);
ring.h357struct s_nring *f_nring_unlink(struct s_nring *node);
ring.h358struct s_nring *f_nring_find(struct s_nring *ring, const char *name);
ring.h358struct s_nring *f_nring_find(struct s_nring *ring, const char *name);
ring_test.c102      struct s_nring link;

struct : s_ring

  File Line   Context
ring.c112void *f_ring_unlink(struct s_ring *node, size_t offset) {
ring.c135 * @param offset (IN) offset of structure s_ring
ring.c152 * @param offset (IN) offset of structure s_ring
ring.c252 * @param offset (IN) offset of structure s_ring
ring.c275 * @param offset (IN) offset of structure s_ring
ring.c380 * @param offset (IN) offset of structure s_ring
ring.c403 * @param offset (IN) offset of structure s_ring
ring.c43 * @param offset (IN) offset of structure s_ring
ring.c47bool f_ring_selftest(struct s_ring *ring, size_t offset) {
ring.c60 * @param offset (IN) offset of structure s_ring
ring.c65bool f_ring_is_in(struct s_ring *is, struct s_ring *in, size_t offset) {
ring.c65bool f_ring_is_in(struct s_ring *is, struct s_ring *in, size_t offset) {
ring.c89void *f_ring_link(struct s_ring *ring, struct s_ring *new, size_t offset) {
ring.c89void *f_ring_link(struct s_ring *ring, struct s_ring *new, size_t offset) {
ring.h29        struct s_ring sibling;
ring.h323bool f_ring_selftest(struct s_ring *ring, size_t offset);
ring.h328bool f_ring_is_in(struct s_ring *is, struct s_ring *in, size_t offset);
ring.h328bool f_ring_is_in(struct s_ring *is, struct s_ring *in, size_t offset);
ring.h333void *f_ring_unlink(struct s_ring *node, size_t offset);
ring.h338void *f_ring_link(struct s_ring *ring, struct s_ring *_new, size_t offset);
ring.h338void *f_ring_link(struct s_ring *ring, struct s_ring *_new, size_t offset);
ring.h351struct s_ring *f_ring_next(struct s_ring *node);
ring.h351struct s_ring *f_ring_next(struct s_ring *node);
ring.h352struct s_ring *f_ring_link(struct s_ring *ring, struct s_ring *node);
ring.h352struct s_ring *f_ring_link(struct s_ring *ring, struct s_ring *node);
ring.h352struct s_ring *f_ring_link(struct s_ring *ring, struct s_ring *node);
ring.h353struct s_ring *f_ring_unlink(struct s_ring *node);
ring.h353struct s_ring *f_ring_unlink(struct s_ring *node);
ring_alloc.c40   struct s_ring brother;
ring_test.c25      struct s_ring link;

typedef : to_mempool

  File Line   Context
ring_alloc.c180to_mempool f_mempool_init(size_t size, void *start) {
ring_alloc.c227int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats) {
ring_alloc.c261int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats) {
ring_alloc.c270void *f_mempool_malloc(to_mempool mempool, size_t size) {
ring_alloc.c305int f_mempool_free(to_mempool mempool, void *mem) {
ring_alloc.c349void *f_mempool_realloc(to_mempool mempool, void *mem, size_t size) {
ring_alloc.c391void *f_mempool_calloc(to_mempool mempool, size_t nmemb, size_t size) {
ring_alloc.h19to_mempool f_mempool_init(size_t size, void *start);
ring_alloc.h34int f_mempool_stats(to_mempool mempool, struct s_mempool_stats *stats);
ring_alloc.h36void *f_mempool_malloc(to_mempool mempool, size_t size);
ring_alloc.h38int f_mempool_free(to_mempool mempool, void *mem);
ring_alloc.h40void *f_mempool_realloc(to_mempool mempool, void *mem, size_t size);
ring_alloc.h42void *f_mempool_calloc(to_mempool mempool, size_t nmemb, size_t size);
ring_alloc_test.c21   to_mempool mempool;

To rings Doc++

File Index

All Tags

Tags by File

Tags referrers

C to HTML Conversion by ctoohtml
Hosted by the courtesy of  
 GitHub  		The stars ASAP english francais spanish
Durée du voyage intersidéral francais
Résolutions de l'ONU en HTML francais
Bussard Ramjet english francais
 DWARF : dwarf2xml english
ELF : libelf examples english
Code presentation : ctoohtml english