lists.c File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.h>
#include "libavrdude.h"

Include dependency graph for lists.c:

Go to the source code of this file.

Classes
struct	LISTNODE
struct	NODEPOOL
struct	LIST

Macros
#define	MAGIC   0xb05b05b0
#define	CHECK_MAGIC   0 /* set to 1 to enable memory overwrite detection */
#define	MALLOC(size, x)   malloc(size)
#define	FREE   free
#define	DEFAULT_POOLSIZE   512
#define	CKMAGIC(p)
#define	CKNPMAGIC(p)
#define	CKLNMAGIC(p)
#define	CKLMAGIC(p)

Typedefs
typedef struct LISTNODE	LISTNODE
typedef struct NODEPOOL	NODEPOOL
typedef struct LIST	LIST

Functions
static int	insert_ln (LIST *l, LISTNODE *ln, void *data_ptr)
static NODEPOOL *	new_nodepool (LIST *l)
static LISTNODE *	get_listnode (LIST *l)
static int	free_listnode (LIST *l, LISTNODE *ln)
LISTID	lcreat (void *liststruct, int elements)
void	ldestroy_cb (LISTID lid, void(*ucleanup)(void *data_ptr))
void	ldestroy (LISTID lid)
int	ladd (LISTID lid, void *p)
int	laddo (LISTID lid, void *p, int(*compare)(const void *p1, const void *p2), LNODEID *firstdup)
int	laddu (LISTID lid, void *p, int(*compare)(const void *p1, const void *p2))
LNODEID	lfirst (LISTID lid)
LNODEID	llast (LISTID lid)
LNODEID	lnext (LNODEID lnid)
LNODEID	lprev (LNODEID lnid)
void *	ldata (LNODEID lnid)
int	lsize (LISTID lid)
LISTID	lcat (LISTID lid1, LISTID lid2)
void *	lget (LISTID lid)
void *	lget_n (LISTID lid, unsigned int n)
LNODEID	lget_ln (LISTID lid, unsigned int n)
int	lins_n (LISTID lid, void *data_ptr, unsigned int n)
int	lins_ln (LISTID lid, LNODEID lnid, void *data_ptr)
static void *	remove_ln (LIST *l, LISTNODE *ln)
void *	lrmv_d (LISTID lid, void *data_ptr)
void *	lrmv_ln (LISTID lid, LNODEID lnid)
void *	lrmv_n (LISTID lid, unsigned int n)
void *	lrmv (LISTID lid)
void *	lsrch (LISTID lid, void *p, int(*compare)(void *p1, void *p2))
void	lsort (LISTID lid, int(*compare)(void *p1, void *p2))
int	lprint (FILE *f, LISTID lid)

---

Class Documentation

LISTNODE

struct LISTNODE

Collaboration diagram for LISTNODE:

Class Members
void *	data
struct LISTNODE *	next
struct LISTNODE *	prev

NODEPOOL

struct NODEPOOL

Collaboration diagram for NODEPOOL:

Class Members
struct NODEPOOL *	chain_next
struct NODEPOOL *	chain_prev

LIST

struct LIST

Collaboration diagram for LIST:

Class Members
LISTNODE *	bottom
short int	free_on_close
int	n_ln_pool
LISTNODE *	next_ln
NODEPOOL *	np_bottom
NODEPOOL *	np_top
int	num
short int	poolsize
LISTNODE *	top

Macro Definition Documentation

CHECK_MAGIC

#define CHECK_MAGIC   0 /* set to 1 to enable memory overwrite detection */

CKLMAGIC

#define CKLMAGIC

(

p

)

CKLNMAGIC

#define CKLNMAGIC

(

p

)

CKMAGIC

#define CKMAGIC

(

p

)

CKNPMAGIC

#define CKNPMAGIC

(

p

)

DEFAULT_POOLSIZE

#define DEFAULT_POOLSIZE   512

FREE

#define FREE   free

MAGIC

#define MAGIC   0xb05b05b0

MALLOC

#define MALLOC	(		size,
			x
	)		malloc(size)

Typedef Documentation

LIST

typedef struct LIST LIST

LISTNODE

typedef struct LISTNODE LISTNODE

NODEPOOL

typedef struct NODEPOOL NODEPOOL

Function Documentation

free_listnode()

static int free_listnode ( LIST *  l, LISTNODE *  ln  )

static

{
  CKLMAGIC(l);
 
  /*--------------------------------------------------
  |  insert the list node at the head of the list of
  |  free list nodes.
   --------------------------------------------------*/
  ln->prev = NULL;
  ln->data = NULL;
  ln->next = l->next_ln;
  l->next_ln = ln;
 
  CKLMAGIC(l);
 
  return 0;
}

References CKLMAGIC, LISTNODE::data, LISTNODE::next, LIST::next_ln, and LISTNODE::prev.

Referenced by remove_ln().

Here is the caller graph for this function:

get_listnode()

static LISTNODE * get_listnode ( LIST *  l )

static

{
  LISTNODE * ln;
  NODEPOOL * np;
 
  CKLMAGIC(l);
 
  if (l->next_ln == NULL) {
    /*--------------------------------------------------
    | allocate a new node pool and chain to the others
     --------------------------------------------------*/
    np = new_nodepool(l);
    if (np == NULL) {
      CKLMAGIC(l);
      return NULL;
    }
 
    if (l->np_top == NULL) {
      /*--------------------------------------------------
      |  this is the first node pool for this list,
      |  directly assign to the top and bottom.
       --------------------------------------------------*/
      l->np_top = np;
      l->np_bottom = np;
      np->chain_next = NULL;
      np->chain_prev = NULL;
    }
    else {
      /*--------------------------------------------------
      |  this is an additional node pool, add it to the
      |  chain.
       --------------------------------------------------*/
      np->chain_next = NULL;
      np->chain_prev = l->np_bottom;
      l->np_bottom->chain_next = np;
      l->np_bottom = np;
    }
 
    /*--------------------------------------------------
    |  set the list's pointer to the next available
    |  list node to the first list node in this new
    |  pool.
     --------------------------------------------------*/
    l->next_ln = (LISTNODE *)&np[1];
 
    CKMAGIC(np);
  }
 
  /*--------------------------------------------------
  |  get the next available list node, set the list's
  |  next available list node to the next one in the
  |  list.
   --------------------------------------------------*/
  ln = l->next_ln;
  l->next_ln = ln->next;
 
  CKMAGIC(ln);
 
  /*--------------------------------------------------
  |  initialize the new list node and return
   --------------------------------------------------*/
  ln->next = NULL;
  ln->prev = NULL;
  ln->data = NULL;
 
  CKLMAGIC(l);
 
  return ln;
}

References NODEPOOL::chain_next, NODEPOOL::chain_prev, CKLMAGIC, CKMAGIC, LISTNODE::data, new_nodepool(), LISTNODE::next, LIST::next_ln, LIST::np_bottom, LIST::np_top, and LISTNODE::prev.

Referenced by insert_ln(), and ladd().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_ln()

static int insert_ln ( LIST *  l, LISTNODE *  ln, void *  data_ptr  )

static

{
  LISTNODE * lnptr;
 
  CKLMAGIC(l);
 
  if (ln==NULL) {
    ladd ( l, data_ptr );
    CKLMAGIC(l);
    return 0;
  }
 
  lnptr = get_listnode(l);
  if (lnptr == NULL) {
#ifdef BOS
    breakpoint();
#endif
    return -1;
  }
 
  CKMAGIC(lnptr);
 
  lnptr->data = data_ptr;
 
  if (ln==l->top) {
    /*------------------------------
    |  insert before the list head
     ------------------------------*/
    lnptr->next = ln;
    lnptr->prev = NULL;
    ln->prev = lnptr;
    l->top = lnptr;
  }
  else if (ln==NULL) {
    /*-----------------
    |  list was empty
     -----------------*/
    lnptr->next = NULL;
    lnptr->prev = l->bottom;
    l->bottom->next = lnptr;
    l->bottom = lnptr;
  }
  else {
    /*-----------------------------------
    |  insert in the middle of the list
     -----------------------------------*/
    lnptr->next = ln;
    lnptr->prev = ln->prev;
    lnptr->next->prev = lnptr;
    lnptr->prev->next = lnptr;
  }
 
  l->num++;
 
  CKLMAGIC(l);
 
  return 0;
}

References LIST::bottom, CKLMAGIC, CKMAGIC, LISTNODE::data, get_listnode(), ladd(), LISTNODE::next, LIST::num, LISTNODE::prev, and LIST::top.

Referenced by laddo(), laddu(), lins_ln(), and lins_n().

Here is the call graph for this function:

Here is the caller graph for this function:

ladd()

int ladd	(	LISTID	lid,
		void *	p
	)

{
  LIST * l;
  LISTNODE *lnptr;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  lnptr = get_listnode(l);
  if (lnptr==NULL) {
#ifdef BOS
    breakpoint();
#endif
    return -1;
  }
 
  CKMAGIC(lnptr);
 
  lnptr->data = p;
 
  if (l->top == NULL) {
    l->top = lnptr;
    l->bottom = lnptr;
    lnptr->next = NULL;
    lnptr->prev = NULL;
  }
  else {
    lnptr->prev = l->bottom;
    lnptr->next = NULL;
    l->bottom->next = lnptr;
    l->bottom = lnptr;
  }
  l->num++;
 
  CKLMAGIC(l);
 
  return 0;
}

References LIST::bottom, CKLMAGIC, CKMAGIC, LISTNODE::data, get_listnode(), LISTNODE::next, LIST::num, LISTNODE::prev, and LIST::top.

Referenced by avr_dup_part(), avrdude_main(), insert_ln(), jtag3_open_common(), laddo(), laddu(), lcat(), lins_n(), pgm_dup(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

laddo()

int laddo	(	LISTID	lid,
		void *	p,
		int(*)(const void *p1, const void *p2)	compare,
		LNODEID *	firstdup
	)

{
  LIST * l;
  LISTNODE * ln;
  int dup, cmp;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  dup = 0;
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    cmp = compare(p,ln->data);
    if (cmp == 0) {
      dup = 1;
      if (firstdup)
  *firstdup = ln;
    }
    if (cmp < 0) {
      insert_ln(l,ln,p);
      CKLMAGIC(l);
      return dup;
    }
    else {
      ln = ln->next;
    }
  }
 
  ladd(l,p);
 
  CKLMAGIC(l);
 
  return dup;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, insert_ln(), ladd(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

laddu()

int laddu	(	LISTID	lid,
		void *	p,
		int(*)(const void *p1, const void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * ln;
  int cmp;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    cmp = compare(p,ln->data);
    if (cmp == 0) {
      CKLMAGIC(l);
      return 0;
    }
    if (cmp < 0) {
      insert_ln(l,ln,p);
      CKLMAGIC(l);
      return 1;
    }
    else {
      ln = ln->next;
    }
  }
 
  ladd(l,p);
 
  CKLMAGIC(l);
 
  return 1;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, insert_ln(), ladd(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lcat()

LISTID lcat	(	LISTID	lid1,
		LISTID	lid2
	)

{
  CKLMAGIC(((LIST *)lid1));
  CKLMAGIC(((LIST *)lid2));
  while (lsize(lid2)) {
    ladd ( lid1, lrmv_n(lid2,1) );
  }
 
  CKLMAGIC(((LIST *)lid1));
  CKLMAGIC(((LIST *)lid2));
 
  return lid1;
}

References CKLMAGIC, ladd(), lrmv_n(), and lsize().

Here is the call graph for this function:

lcreat()

LISTID lcreat	(	void *	liststruct,
		int	elements
	)

{
  LIST * l;
 
  if (liststruct == NULL) {
    /*--------------------------------------------------
      allocate memory for the list itself
      --------------------------------------------------*/
    l = (LIST *) MALLOC ( sizeof(LIST), "list struct" );
    if (l == NULL) {
      return NULL;
    }
    l->free_on_close = 1;
  }
  else {
    /*-----------------------------------------------------------------
      use the memory given to us for the list structure
      -----------------------------------------------------------------*/
    l = liststruct;
    l->free_on_close = 0;
  }
 
  /*--------------------------------------------------
  |  initialize the list
   --------------------------------------------------*/
#if CHECK_MAGIC
  l->magic1 = MAGIC;
  l->magic2 = MAGIC;
#endif
  l->top = NULL;
  l->bottom = NULL;
  l->num = 0;
 
  if (elements == 0) {
    l->poolsize = DEFAULT_POOLSIZE;
  }
  else {
    l->poolsize = (short)(elements*sizeof(LISTNODE)+sizeof(NODEPOOL));
  }
 
  l->n_ln_pool = (l->poolsize-sizeof(NODEPOOL))/sizeof(LISTNODE);
 
  if (l->n_ln_pool < 5) {
    if (!liststruct) {
      FREE(l);
    }
    return NULL;
  }
 
  l->np_top = NULL;
  l->np_bottom = NULL;
  l->next_ln = NULL;
 
  CKLMAGIC(l);
 
  return (LISTID)l;
}

References LIST::bottom, CKLMAGIC, DEFAULT_POOLSIZE, FREE, LIST::free_on_close, MAGIC, MALLOC, LIST::n_ln_pool, LIST::next_ln, LIST::np_bottom, LIST::np_top, LIST::num, LIST::poolsize, and LIST::top.

Referenced by avr_new_part(), avrdude_main(), init_config(), pgm_dup(), pgm_new(), and yyparse().

Here is the caller graph for this function:

ldata()

void * ldata

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->data;
}

References CKMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), pgm_dup(), sort_programmer_compare(), stk500_close(), stk500_initialize(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

Here is the caller graph for this function:

ldestroy()

void ldestroy

(

LISTID

lid

)

{
  LIST * l;
  NODEPOOL * p1, * p2;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  /*--------------------------------------------------
  |  free each node pool - start at the first node
  |  pool and free each successive until there are
  |  no more.
   --------------------------------------------------*/
  p1 = l->np_top;
  while (p1 != NULL) {
    p2 = p1->chain_next;
    FREE(p1);
    p1 = p2;
  }
 
  /*--------------------------------------------------
  |  now free the memory occupied by the list itself
   --------------------------------------------------*/
  if (l->free_on_close) {
    FREE ( l );
  }
}

References NODEPOOL::chain_next, CKLMAGIC, FREE, LIST::free_on_close, and LIST::np_top.

Referenced by cleanup_main(), and ldestroy_cb().

Here is the caller graph for this function:

ldestroy_cb()

void ldestroy_cb	(	LISTID	lid,
		void(*)(void *data_ptr)	ucleanup
	)

{
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
  while (ln != NULL) {
    ucleanup ( ln->data );
    ln = ln->next;
  }
 
  ldestroy ( l );
}

References CKLMAGIC, LISTNODE::data, ldestroy(), LISTNODE::next, and LIST::top.

Referenced by avr_free_part(), cleanup_config(), cleanup_main(), pgm_free(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lfirst()

LNODEID lfirst

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->top;
}

References CKLMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), pgm_dup(), sort_programmer_compare(), stk500_close(), stk500_initialize(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

Here is the caller graph for this function:

lget()

void * lget

(

LISTID

lid

)

{
  LIST * l;
  LISTNODE * p;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  p = l->bottom;
 
  if (p == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return p->data;
  }
}

References LIST::bottom, CKLMAGIC, and LISTNODE::data.

lget_ln()

LNODEID lget_ln	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)lsize(l))) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (i!=n) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  CKLMAGIC(l);
  return (LNODEID)ln;
}

References CKLMAGIC, CKMAGIC, lsize(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lget_n()

void * lget_n	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)lsize(l))) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (ln) {
    CKLMAGIC(l);
    return ln->data;
  }
  else {
    CKLMAGIC(l);
    return NULL;
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, lsize(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lins_ln()

int lins_ln	(	LISTID	lid,
		LNODEID	lnid,
		void *	data_ptr
	)

{
  LIST * l;
  LISTNODE * ln;
  LISTNODE * ln_ptr;
 
  l = (LIST *)lid;
  ln = (LISTNODE *)lnid;
 
  CKLMAGIC(l);
 
  CKMAGIC(ln);
 
  /*-----------------------------------------
  |  validate that ln is indeed in the list
   -----------------------------------------*/
  ln_ptr = l->top;
  while ((ln_ptr!=NULL)&&(ln_ptr!=ln)) {
    CKMAGIC(ln_ptr);
    ln_ptr = ln_ptr->next;
  }
 
  if (ln_ptr == NULL) {
    CKLMAGIC(l);
    return -1;
  }
 
  CKLMAGIC(l);
 
  /*--------------------------------
  |  insert the data into the list
   --------------------------------*/
  return insert_ln ( l, ln, data_ptr );
}

References CKLMAGIC, CKMAGIC, insert_ln(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lins_n()

int lins_n	(	LISTID	lid,
		void *	data_ptr,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)(l->num+1))) {
    return -1;
  }
 
  if (l->num == 0) {
    return ladd ( lid, data_ptr );
  }
 
  /*----------------------------------
  |  locate the nth item in the list
   ----------------------------------*/
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (!ln) {
    CKLMAGIC(l);
    return -1;
  }
 
  CKLMAGIC(l);
 
  /*-----------------------------------------
  |  insert before the nth item in the list
   -----------------------------------------*/
  return insert_ln ( l, ln, data_ptr );
}

References CKLMAGIC, CKMAGIC, insert_ln(), ladd(), LISTNODE::next, LIST::num, and LIST::top.

Here is the call graph for this function:

llast()

LNODEID llast

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->bottom;
}

References CKLMAGIC.

lnext()

LNODEID lnext

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->next;
}

References CKMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), Slic3r::connect_monotonic_regions(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), lprint(), pgm_dup(), Slic3r::smooth_compensation_banded(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

Here is the caller graph for this function:

lprev()

LNODEID lprev

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->prev;
}

References CKMAGIC.

Referenced by Slic3r::take_ccw_limited(), and Slic3r::take_cw_limited().

Here is the caller graph for this function:

lprint()

int lprint	(	FILE *	f,
		LISTID	lid
	)

{
  LIST * l;
  LISTNODE * ln;
  NODEPOOL * np;
  int count;
 
  l = (LIST *)lid;
 
  fprintf ( f, "list id %p internal data structures:\n", 
            lid );
#if CHECK_MAGIC
  if ((l->magic1 != MAGIC) || (l->magic2 != MAGIC)) {
    fprintf ( f, "  *** WARNING: LIST MAGIC IS CORRUPT ***\n" );
  }
  fprintf ( f, 
            "  magic1=0x%08x\n"
            "  magic2=0x%08x\n",
            l->magic1, l->magic2 );
#endif
  fprintf ( f, "   num f pool n_ln        top     bottom    next_ln     np_top  np_bottom\n" );
  fprintf ( f, "  ---- - ---- ---- ---------- ---------- ---------- ---------- ----------\n" );
  fprintf ( f, "  %4d %1d %4d %4d %10p %10p %10p %10p %10p\n",
            l->num, l->free_on_close, l->poolsize, l->n_ln_pool, 
            l->top, l->bottom,
            l->next_ln, l->np_top, l->np_bottom );
  
 
  fprintf ( f, 
            "  node pools:\n"
            "     idx         np     magic1       next       prev     magic2\n"
            "    ---- ---------- ---------- ---------- ---------- ----------\n" );
  count = 0;
  np = l->np_top;
  while (np != NULL) {
    count++;
    fprintf ( f, "    %4d %10p 0x%08x %10p %10p 0x%08x\n", 
              count, np, 
#if CHECK_MAGIC
              np->magic1, 
#else
              0,
#endif
              np->chain_next, np->chain_prev, 
#if CHECK_MAGIC
              np->magic2
#else
              0
#endif
      );
    np = np->chain_next;
  }
 
  if (f) {
    fprintf ( f, 
              "  list elements:\n"
              "       n         ln     magic1       next       prev       data     magic2\n"
              "    ---- ---------- ---------- ---------- ---------- ---------- ----------\n" );
    count = 0;
    ln = l->top;
    while (ln != NULL) {
      count++;
      fprintf ( f, "    %4d %10p %10x %10p %10p %10p %10x\n", 
                count, ln, 
#if CHECK_MAGIC
                ln->magic1,
#else
                0,
#endif
                ln->next, ln->prev, ln->data, 
#if CHECK_MAGIC
                ln->magic2
#else
                0
#endif
        );
      ln = lnext(ln);
    }
    if (count != l->num) {
      fprintf ( f, 
                "  *** list count is not correct\n"
                "  *** list id indicates %d, counted items = %d\n", 
                l->num, count );
    }
  }
 
  return 0;
}

References LIST::bottom, NODEPOOL::chain_next, NODEPOOL::chain_prev, CHECK_MAGIC, LISTNODE::data, LIST::free_on_close, lnext(), MAGIC, LIST::n_ln_pool, LISTNODE::next, LIST::next_ln, LIST::np_bottom, LIST::np_top, LIST::num, LIST::poolsize, LISTNODE::prev, and LIST::top.

Here is the call graph for this function:

lrmv()

void * lrmv

(

LISTID

lid

)

{
  LIST * l;
  LISTNODE * p;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  p = l->bottom;
 
  if (p == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, p );
  }
}

References LIST::bottom, CKLMAGIC, and remove_ln().

Here is the call graph for this function:

lrmv_d()

void * lrmv_d	(	LISTID	lid,
		void *	data_ptr
	)

{
  LIST * l;
  LISTNODE * ln;
  int i;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  i = 0;
  ln = l->top;
  while (ln && (ln->data != data_ptr)) {
    i++;
    CKMAGIC(ln);
    ln = ln->next;
  }
 
  if (ln == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, ln );
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, remove_ln(), and LIST::top.

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lrmv_ln()

void * lrmv_ln	(	LISTID	lid,
		LNODEID	lnid
	)

{
  LIST * l;
  LISTNODE * ln;
  LISTNODE * p;
 
  l = (LIST *)lid;
  ln = (LISTNODE *)lnid;
 
  CKLMAGIC(l);
 
  CKMAGIC(ln);
 
  p = l->top;
  while ((p!=NULL)&&(p!=ln)) {
    CKMAGIC(p);
    p = p->next;
  }
  
  if (p==NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, p );
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::next, remove_ln(), and LIST::top.

Here is the call graph for this function:

lrmv_n()

void * lrmv_n	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)l->num)) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (ln) {
    CKLMAGIC(l);
    return remove_ln ( l, ln );
  }
  else {
    CKLMAGIC(l);
    return NULL;
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::next, LIST::num, remove_ln(), and LIST::top.

Referenced by assign_pin_list(), lcat(), parse_cmdbits(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lsize()

int lsize

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->num;
}

References CKLMAGIC.

Referenced by assign_pin_list(), avrdude_main(), lcat(), lget_ln(), lget_n(), parse_cmdbits(), and yyparse().

Here is the caller graph for this function:

lsort()

void lsort	(	LISTID	lid,
		int(*)(void *p1, void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * lt; /* this */
  LISTNODE * ln; /* next */
  int unsorted = 1;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  while(unsorted){
    lt = l->top;
    unsorted = 0;
    while (lt!=NULL) {
      CKMAGIC(lt);
      ln = lt->next;
      if (ln!= NULL && compare(lt->data,ln->data) > 0) {
        void * p = ln->data;
        ln->data = lt->data;
        lt->data = p;
        unsorted = 1;
      }
      lt = ln;
    }
  }
 
  CKLMAGIC(l);
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, and LIST::top.

Referenced by sort_avrparts(), and sort_programmers().

Here is the caller graph for this function:

lsrch()

void * lsrch	(	LISTID	lid,
		void *	p,
		int(*)(void *p1, void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    if (compare(p,ln->data) == 0) {
      CKLMAGIC(l);
      return ln->data;
    }
    else {
      ln = ln->next;
    }
  }
 
  CKLMAGIC(l);
  return NULL;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, and LIST::top.

new_nodepool()

static NODEPOOL * new_nodepool ( LIST *  l )

static

{
  NODEPOOL * np;
  LISTNODE * ln;
  int i;
 
  CKLMAGIC(l);
 
  /*--------------------------------------------------
  |  get a block of memory for the new pool
   --------------------------------------------------*/
  np = (NODEPOOL *) MALLOC ( l->poolsize, "list node pool" );
  if (np == NULL) {
    return NULL;
  }
 
  /*--------------------------------------------------
  |  initialize the chaining information at the
  |  beginning of the pool.
   --------------------------------------------------*/
#if CHECK_MAGIC
  np->magic1 = MAGIC;
#endif
  np->chain_next = NULL;
  np->chain_prev = NULL;
#if CHECK_MAGIC
  np->magic2 = MAGIC;
#endif
 
  /*--------------------------------------------------
  |  initialize all the list nodes within the node
  |  pool, which begin just after the NODEPOOL
  |  structure at the beginning of the memory block
   --------------------------------------------------*/
  ln = (LISTNODE *) (&np[1]);
 
#if CHECK_MAGIC
  ln[0].magic1 = MAGIC;
#endif
  ln[0].data = NULL;
  ln[0].next = &ln[1];
  ln[0].prev = NULL;
#if CHECK_MAGIC
  ln[0].magic2 = MAGIC;
#endif
 
  for (i=1; i<l->n_ln_pool-1; i++) {
#if CHECK_MAGIC
    ln[i].magic1 = MAGIC;
#endif
    ln[i].data = NULL;
    ln[i].next = &ln[i+1];
    ln[i].prev = &ln[i-1];
#if CHECK_MAGIC
    ln[i].magic2 = MAGIC;
#endif
  }
 
#if CHECK_MAGIC
  ln[l->n_ln_pool-1].magic1 = MAGIC;
#endif
  ln[l->n_ln_pool-1].data = NULL;
  ln[l->n_ln_pool-1].next = NULL;
  ln[l->n_ln_pool-1].prev = &ln[l->n_ln_pool-2];
#if CHECK_MAGIC
  ln[l->n_ln_pool-1].magic2 = MAGIC;
#endif
 
  CKMAGIC(np);
 
  CKLMAGIC(l);
 
  return np;
}

References NODEPOOL::chain_next, NODEPOOL::chain_prev, CKLMAGIC, CKMAGIC, LISTNODE::data, MAGIC, MALLOC, LIST::n_ln_pool, LISTNODE::next, LIST::poolsize, and LISTNODE::prev.

Referenced by get_listnode().

Here is the caller graph for this function:

remove_ln()

static void * remove_ln ( LIST *  l, LISTNODE *  ln  )

static

{
  void * r;
 
  CKLMAGIC(l);
 
  CKMAGIC(ln);
 
  if (ln==l->top) {
    /*------------------------------
    |  remove the head of the list
     ------------------------------*/
    l->top = ln->next;
    if (l->top != NULL) {
      l->top->prev = NULL;
    }
    else {
      /*----------------------------------------
      |  this was the only item in the list
       ----------------------------------------*/
      l->bottom = NULL;
    }
  }
  else if (ln==l->bottom) {
    /*------------------------------
    |  remove the tail of the list
     ------------------------------*/
    l->bottom = ln->prev;
    if (l->bottom != NULL) {
      l->bottom->next = NULL;
    }
  }
  else {
    /*-------------------------------------
    |  remove from the middle of the list
     -------------------------------------*/
    ln->prev->next = ln->next;
    ln->next->prev = ln->prev;
  }
 
  /*-----------------------------
  |  prepare to return the data
   -----------------------------*/
  r = ln->data;
 
  /*-----------------------------------------------
  |  free the listnode for re-use
   -----------------------------------------------*/
  free_listnode(l,ln);
 
  /*------------------------------------
  |  adjust the item count of the list
   ------------------------------------*/
  l->num--;
 
  CKLMAGIC(l);
 
  return r;
}

References LIST::bottom, CKLMAGIC, CKMAGIC, LISTNODE::data, free_listnode(), LISTNODE::next, LIST::num, LISTNODE::prev, and LIST::top.

Referenced by lrmv(), lrmv_d(), lrmv_ln(), and lrmv_n().

Here is the call graph for this function:

Here is the caller graph for this function: