Hosted by the courtesy of  
http://www.free.fr  		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  
http://www.free.fr  		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