libcoap  4.2.1
utlist.h File Reference
#include <assert.h>
+ Include dependency graph for utlist.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define UTLIST_VERSION   2.0.2
 
#define LDECLTYPE(x)   __typeof(x)
 
#define IF_NO_DECLTYPE(x)
 
#define UTLIST_SV(elt, list)
 
#define UTLIST_NEXT(elt, list, next)   ((elt)->next)
 
#define UTLIST_NEXTASGN(elt, list, to, next)   ((elt)->next)=(to)
 
#define UTLIST_PREVASGN(elt, list, to, prev)   ((elt)->prev)=(to)
 
#define UTLIST_RS(list)
 
#define UTLIST_CASTASGN(a, b)   (a)=(b)
 
#define LL_SORT(list, cmp)   LL_SORT2(list, cmp, next)
 
#define LL_SORT2(list, cmp, next)
 
#define DL_SORT(list, cmp)   DL_SORT2(list, cmp, prev, next)
 
#define DL_SORT2(list, cmp, prev, next)
 
#define CDL_SORT(list, cmp)   CDL_SORT2(list, cmp, prev, next)
 
#define CDL_SORT2(list, cmp, prev, next)
 
#define LL_PREPEND(head, add)   LL_PREPEND2(head,add,next)
 
#define LL_PREPEND2(head, add, next)
 
#define LL_CONCAT(head1, head2)   LL_CONCAT2(head1,head2,next)
 
#define LL_CONCAT2(head1, head2, next)
 
#define LL_APPEND(head, add)   LL_APPEND2(head,add,next)
 
#define LL_APPEND2(head, add, next)
 
#define LL_INSERT_INORDER(head, add, cmp)   LL_INSERT_INORDER2(head,add,cmp,next)
 
#define LL_INSERT_INORDER2(head, add, cmp, next)
 
#define LL_LOWER_BOUND(head, elt, like, cmp)   LL_LOWER_BOUND2(head,elt,like,cmp,next)
 
#define LL_LOWER_BOUND2(head, elt, like, cmp, next)
 
#define LL_DELETE(head, del)   LL_DELETE2(head,del,next)
 
#define LL_DELETE2(head, del, next)
 
#define LL_COUNT(head, el, counter)   LL_COUNT2(head,el,counter,next) \
 
#define LL_COUNT2(head, el, counter, next)
 
#define LL_FOREACH(head, el)   LL_FOREACH2(head,el,next)
 
#define LL_FOREACH2(head, el, next)   for ((el) = (head); el; (el) = (el)->next)
 
#define LL_FOREACH_SAFE(head, el, tmp)   LL_FOREACH_SAFE2(head,el,tmp,next)
 
#define LL_FOREACH_SAFE2(head, el, tmp, next)   for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))
 
#define LL_SEARCH_SCALAR(head, out, field, val)   LL_SEARCH_SCALAR2(head,out,field,val,next)
 
#define LL_SEARCH_SCALAR2(head, out, field, val, next)
 
#define LL_SEARCH(head, out, elt, cmp)   LL_SEARCH2(head,out,elt,cmp,next)
 
#define LL_SEARCH2(head, out, elt, cmp, next)
 
#define LL_REPLACE_ELEM2(head, el, add, next)
 
#define LL_REPLACE_ELEM(head, el, add)   LL_REPLACE_ELEM2(head, el, add, next)
 
#define LL_PREPEND_ELEM2(head, el, add, next)
 
#define LL_PREPEND_ELEM(head, el, add)   LL_PREPEND_ELEM2(head, el, add, next)
 
#define LL_APPEND_ELEM2(head, el, add, next)
 
#define LL_APPEND_ELEM(head, el, add)   LL_APPEND_ELEM2(head, el, add, next)
 
#define DL_PREPEND(head, add)   DL_PREPEND2(head,add,prev,next)
 
#define DL_PREPEND2(head, add, prev, next)
 
#define DL_APPEND(head, add)   DL_APPEND2(head,add,prev,next)
 
#define DL_APPEND2(head, add, prev, next)
 
#define DL_INSERT_INORDER(head, add, cmp)   DL_INSERT_INORDER2(head,add,cmp,next)
 
#define DL_INSERT_INORDER2(head, add, cmp, next)
 
#define DL_LOWER_BOUND(head, elt, like, cmp)   DL_LOWER_BOUND2(head,elt,like,cmp,next)
 
#define DL_LOWER_BOUND2(head, elt, like, cmp, next)
 
#define DL_CONCAT(head1, head2)   DL_CONCAT2(head1,head2,prev,next)
 
#define DL_CONCAT2(head1, head2, prev, next)
 
#define DL_DELETE(head, del)   DL_DELETE2(head,del,prev,next)
 
#define DL_DELETE2(head, del, prev, next)
 
#define DL_COUNT(head, el, counter)   DL_COUNT2(head,el,counter,next) \
 
#define DL_COUNT2(head, el, counter, next)
 
#define DL_FOREACH(head, el)   DL_FOREACH2(head,el,next)
 
#define DL_FOREACH2(head, el, next)   for ((el) = (head); el; (el) = (el)->next)
 
#define DL_FOREACH_SAFE(head, el, tmp)   DL_FOREACH_SAFE2(head,el,tmp,next)
 
#define DL_FOREACH_SAFE2(head, el, tmp, next)   for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))
 
#define DL_SEARCH_SCALAR   LL_SEARCH_SCALAR
 
#define DL_SEARCH   LL_SEARCH
 
#define DL_SEARCH_SCALAR2   LL_SEARCH_SCALAR2
 
#define DL_SEARCH2   LL_SEARCH2
 
#define DL_REPLACE_ELEM2(head, el, add, prev, next)
 
#define DL_REPLACE_ELEM(head, el, add)   DL_REPLACE_ELEM2(head, el, add, prev, next)
 
#define DL_PREPEND_ELEM2(head, el, add, prev, next)
 
#define DL_PREPEND_ELEM(head, el, add)   DL_PREPEND_ELEM2(head, el, add, prev, next)
 
#define DL_APPEND_ELEM2(head, el, add, prev, next)
 
#define DL_APPEND_ELEM(head, el, add)   DL_APPEND_ELEM2(head, el, add, prev, next)
 
#define CDL_APPEND(head, add)   CDL_APPEND2(head,add,prev,next)
 
#define CDL_APPEND2(head, add, prev, next)
 
#define CDL_PREPEND(head, add)   CDL_PREPEND2(head,add,prev,next)
 
#define CDL_PREPEND2(head, add, prev, next)
 
#define CDL_INSERT_INORDER(head, add, cmp)   CDL_INSERT_INORDER2(head,add,cmp,next)
 
#define CDL_INSERT_INORDER2(head, add, cmp, next)
 
#define CDL_LOWER_BOUND(head, elt, like, cmp)   CDL_LOWER_BOUND2(head,elt,like,cmp,next)
 
#define CDL_LOWER_BOUND2(head, elt, like, cmp, next)
 
#define CDL_DELETE(head, del)   CDL_DELETE2(head,del,prev,next)
 
#define CDL_DELETE2(head, del, prev, next)
 
#define CDL_COUNT(head, el, counter)   CDL_COUNT2(head,el,counter,next) \
 
#define CDL_COUNT2(head, el, counter, next)
 
#define CDL_FOREACH(head, el)   CDL_FOREACH2(head,el,next)
 
#define CDL_FOREACH2(head, el, next)   for ((el)=(head);el;(el)=(((el)->next==(head)) ? NULL : (el)->next))
 
#define CDL_FOREACH_SAFE(head, el, tmp1, tmp2)   CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next)
 
#define CDL_FOREACH_SAFE2(head, el, tmp1, tmp2, prev, next)
 
#define CDL_SEARCH_SCALAR(head, out, field, val)   CDL_SEARCH_SCALAR2(head,out,field,val,next)
 
#define CDL_SEARCH_SCALAR2(head, out, field, val, next)
 
#define CDL_SEARCH(head, out, elt, cmp)   CDL_SEARCH2(head,out,elt,cmp,next)
 
#define CDL_SEARCH2(head, out, elt, cmp, next)
 
#define CDL_REPLACE_ELEM2(head, el, add, prev, next)
 
#define CDL_REPLACE_ELEM(head, el, add)   CDL_REPLACE_ELEM2(head, el, add, prev, next)
 
#define CDL_PREPEND_ELEM2(head, el, add, prev, next)
 
#define CDL_PREPEND_ELEM(head, el, add)   CDL_PREPEND_ELEM2(head, el, add, prev, next)
 
#define CDL_APPEND_ELEM2(head, el, add, prev, next)
 
#define CDL_APPEND_ELEM(head, el, add)   CDL_APPEND_ELEM2(head, el, add, prev, next)
 

Macro Definition Documentation

◆ CDL_APPEND

#define CDL_APPEND (   head,
  add 
)    CDL_APPEND2(head,add,prev,next)

Definition at line 861 of file utlist.h.

◆ CDL_APPEND2

#define CDL_APPEND2 (   head,
  add,
  prev,
  next 
)
Value:
do { \
if (head) { \
(add)->prev = (head)->prev; \
(add)->next = (head); \
(head)->prev = (add); \
(add)->prev->next = (add); \
} else { \
(add)->prev = (add); \
(add)->next = (add); \
(head) = (add); \
} \
} while (0)

Definition at line 864 of file utlist.h.

◆ CDL_APPEND_ELEM

#define CDL_APPEND_ELEM (   head,
  el,
  add 
)    CDL_APPEND_ELEM2(head, el, add, prev, next)

Definition at line 1041 of file utlist.h.

◆ CDL_APPEND_ELEM2

#define CDL_APPEND_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
if (el) { \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el)->next; \
(add)->prev = (el); \
(el)->next = (add); \
(add)->next->prev = (add); \
} else { \
CDL_PREPEND2(head, add, prev, next); \
} \
} while (0)

Definition at line 1027 of file utlist.h.

◆ CDL_COUNT

#define CDL_COUNT (   head,
  el,
  counter 
)    CDL_COUNT2(head,el,counter,next) \

Definition at line 941 of file utlist.h.

◆ CDL_COUNT2

#define CDL_COUNT2 (   head,
  el,
  counter,
  next 
)
Value:
do { \
(counter) = 0; \
CDL_FOREACH2(head,el,next) { ++(counter); } \
} while (0)

Definition at line 944 of file utlist.h.

◆ CDL_DELETE

#define CDL_DELETE (   head,
  del 
)    CDL_DELETE2(head,del,prev,next)

Definition at line 927 of file utlist.h.

◆ CDL_DELETE2

#define CDL_DELETE2 (   head,
  del,
  prev,
  next 
)
Value:
do { \
if (((head)==(del)) && ((head)->next == (head))) { \
(head) = NULL; \
} else { \
(del)->next->prev = (del)->prev; \
(del)->prev->next = (del)->next; \
if ((del) == (head)) (head)=(del)->next; \
} \
} while (0)

Definition at line 930 of file utlist.h.

◆ CDL_FOREACH

#define CDL_FOREACH (   head,
  el 
)    CDL_FOREACH2(head,el,next)

Definition at line 950 of file utlist.h.

◆ CDL_FOREACH2

#define CDL_FOREACH2 (   head,
  el,
  next 
)    for ((el)=(head);el;(el)=(((el)->next==(head)) ? NULL : (el)->next))

Definition at line 953 of file utlist.h.

◆ CDL_FOREACH_SAFE

#define CDL_FOREACH_SAFE (   head,
  el,
  tmp1,
  tmp2 
)    CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next)

Definition at line 956 of file utlist.h.

◆ CDL_FOREACH_SAFE2

#define CDL_FOREACH_SAFE2 (   head,
  el,
  tmp1,
  tmp2,
  prev,
  next 
)
Value:
for ((el) = (head), (tmp1) = (head) ? (head)->prev : NULL; \
(el) && ((tmp2) = (el)->next, 1); \
(el) = ((el) == (tmp1) ? NULL : (tmp2)))

Definition at line 959 of file utlist.h.

◆ CDL_INSERT_INORDER

#define CDL_INSERT_INORDER (   head,
  add,
  cmp 
)    CDL_INSERT_INORDER2(head,add,cmp,next)

Definition at line 895 of file utlist.h.

◆ CDL_INSERT_INORDER2

#define CDL_INSERT_INORDER2 (   head,
  add,
  cmp,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
if (head) { \
CDL_LOWER_BOUND(head, _tmp, add, cmp); \
CDL_APPEND_ELEM(head, _tmp, add); \
} else { \
(head) = (add); \
(head)->next = (head); \
(head)->prev = (head); \
} \
} while (0)

Definition at line 898 of file utlist.h.

◆ CDL_LOWER_BOUND

#define CDL_LOWER_BOUND (   head,
  elt,
  like,
  cmp 
)    CDL_LOWER_BOUND2(head,elt,like,cmp,next)

Definition at line 911 of file utlist.h.

◆ CDL_LOWER_BOUND2

#define CDL_LOWER_BOUND2 (   head,
  elt,
  like,
  cmp,
  next 
)
Value:
do { \
if ((head) == NULL || (cmp(head, like)) >= 0) { \
(elt) = NULL; \
} else { \
for ((elt) = (head); (elt)->next != (head); (elt) = (elt)->next) { \
if ((cmp((elt)->next, like)) >= 0) { \
break; \
} \
} \
} \
} while (0)

Definition at line 914 of file utlist.h.

◆ CDL_PREPEND

#define CDL_PREPEND (   head,
  add 
)    CDL_PREPEND2(head,add,prev,next)

Definition at line 878 of file utlist.h.

◆ CDL_PREPEND2

#define CDL_PREPEND2 (   head,
  add,
  prev,
  next 
)
Value:
do { \
if (head) { \
(add)->prev = (head)->prev; \
(add)->next = (head); \
(head)->prev = (add); \
(add)->prev->next = (add); \
} else { \
(add)->prev = (add); \
(add)->next = (add); \
} \
(head) = (add); \
} while (0)

Definition at line 881 of file utlist.h.

◆ CDL_PREPEND_ELEM

#define CDL_PREPEND_ELEM (   head,
  el,
  add 
)    CDL_PREPEND_ELEM2(head, el, add, prev, next)

Definition at line 1024 of file utlist.h.

◆ CDL_PREPEND_ELEM2

#define CDL_PREPEND_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
if (el) { \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el); \
(add)->prev = (el)->prev; \
(el)->prev = (add); \
(add)->prev->next = (add); \
if ((head) == (el)) { \
(head) = (add); \
} \
} else { \
CDL_APPEND2(head, add, prev, next); \
} \
} while (0)

Definition at line 1007 of file utlist.h.

◆ CDL_REPLACE_ELEM

#define CDL_REPLACE_ELEM (   head,
  el,
  add 
)    CDL_REPLACE_ELEM2(head, el, add, prev, next)

Definition at line 1004 of file utlist.h.

◆ CDL_REPLACE_ELEM2

#define CDL_REPLACE_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
assert((head) != NULL); \
assert((el) != NULL); \
assert((add) != NULL); \
if ((el)->next == (el)) { \
(add)->next = (add); \
(add)->prev = (add); \
(head) = (add); \
} else { \
(add)->next = (el)->next; \
(add)->prev = (el)->prev; \
(add)->next->prev = (add); \
(add)->prev->next = (add); \
if ((head) == (el)) { \
(head) = (add); \
} \
} \
} while (0)

Definition at line 984 of file utlist.h.

◆ CDL_SEARCH

#define CDL_SEARCH (   head,
  out,
  elt,
  cmp 
)    CDL_SEARCH2(head,out,elt,cmp,next)

Definition at line 974 of file utlist.h.

◆ CDL_SEARCH2

#define CDL_SEARCH2 (   head,
  out,
  elt,
  cmp,
  next 
)
Value:
do { \
CDL_FOREACH2(head,out,next) { \
if ((cmp(out,elt))==0) break; \
} \
} while (0)

Definition at line 977 of file utlist.h.

◆ CDL_SEARCH_SCALAR

#define CDL_SEARCH_SCALAR (   head,
  out,
  field,
  val 
)    CDL_SEARCH_SCALAR2(head,out,field,val,next)

Definition at line 964 of file utlist.h.

◆ CDL_SEARCH_SCALAR2

#define CDL_SEARCH_SCALAR2 (   head,
  out,
  field,
  val,
  next 
)
Value:
do { \
CDL_FOREACH2(head,out,next) { \
if ((out)->field == (val)) break; \
} \
} while (0)

Definition at line 967 of file utlist.h.

◆ CDL_SORT

#define CDL_SORT (   list,
  cmp 
)    CDL_SORT2(list, cmp, prev, next)

Definition at line 236 of file utlist.h.

◆ CDL_SORT2

#define CDL_SORT2 (   list,
  cmp,
  prev,
  next 
)

Definition at line 239 of file utlist.h.

◆ DL_APPEND

#define DL_APPEND (   head,
  add 
)    DL_APPEND2(head,add,prev,next)

Definition at line 637 of file utlist.h.

◆ DL_APPEND2

#define DL_APPEND2 (   head,
  add,
  prev,
  next 
)
Value:
do { \
if (head) { \
(add)->prev = (head)->prev; \
(head)->prev->next = (add); \
(head)->prev = (add); \
(add)->next = NULL; \
} else { \
(head)=(add); \
(head)->prev = (head); \
(head)->next = NULL; \
} \
} while (0)

Definition at line 640 of file utlist.h.

◆ DL_APPEND_ELEM

#define DL_APPEND_ELEM (   head,
  el,
  add 
)    DL_APPEND_ELEM2(head, el, add, prev, next)

Definition at line 822 of file utlist.h.

◆ DL_APPEND_ELEM2

#define DL_APPEND_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
if (el) { \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el)->next; \
(add)->prev = (el); \
(el)->next = (add); \
if ((add)->next) { \
(add)->next->prev = (add); \
} else { \
(head)->prev = (add); \
} \
} else { \
DL_PREPEND2(head, add, prev, next); \
} \
} while (0) \

Definition at line 804 of file utlist.h.

◆ DL_CONCAT

#define DL_CONCAT (   head1,
  head2 
)    DL_CONCAT2(head1,head2,prev,next)

Definition at line 686 of file utlist.h.

◆ DL_CONCAT2

#define DL_CONCAT2 (   head1,
  head2,
  prev,
  next 
)
Value:
do { \
LDECLTYPE(head1) _tmp; \
if (head2) { \
if (head1) { \
UTLIST_CASTASGN(_tmp, (head2)->prev); \
(head2)->prev = (head1)->prev; \
(head1)->prev->next = (head2); \
UTLIST_CASTASGN((head1)->prev, _tmp); \
} else { \
(head1)=(head2); \
} \
} \
} while (0)

Definition at line 689 of file utlist.h.

◆ DL_COUNT

#define DL_COUNT (   head,
  el,
  counter 
)    DL_COUNT2(head,el,counter,next) \

Definition at line 726 of file utlist.h.

◆ DL_COUNT2

#define DL_COUNT2 (   head,
  el,
  counter,
  next 
)
Value:
do { \
(counter) = 0; \
DL_FOREACH2(head,el,next) { ++(counter); } \
} while (0)

Definition at line 729 of file utlist.h.

◆ DL_DELETE

#define DL_DELETE (   head,
  del 
)    DL_DELETE2(head,del,prev,next)

Definition at line 704 of file utlist.h.

◆ DL_DELETE2

#define DL_DELETE2 (   head,
  del,
  prev,
  next 
)
Value:
do { \
assert((head) != NULL); \
assert((del)->prev != NULL); \
if ((del)->prev == (del)) { \
(head)=NULL; \
} else if ((del)==(head)) { \
(del)->next->prev = (del)->prev; \
(head) = (del)->next; \
} else { \
(del)->prev->next = (del)->next; \
if ((del)->next) { \
(del)->next->prev = (del)->prev; \
} else { \
(head)->prev = (del)->prev; \
} \
} \
} while (0)

Definition at line 707 of file utlist.h.

◆ DL_FOREACH

#define DL_FOREACH (   head,
  el 
)    DL_FOREACH2(head,el,next)

Definition at line 735 of file utlist.h.

◆ DL_FOREACH2

#define DL_FOREACH2 (   head,
  el,
  next 
)    for ((el) = (head); el; (el) = (el)->next)

Definition at line 738 of file utlist.h.

◆ DL_FOREACH_SAFE

#define DL_FOREACH_SAFE (   head,
  el,
  tmp 
)    DL_FOREACH_SAFE2(head,el,tmp,next)

Definition at line 742 of file utlist.h.

◆ DL_FOREACH_SAFE2

#define DL_FOREACH_SAFE2 (   head,
  el,
  tmp,
  next 
)    for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))

Definition at line 745 of file utlist.h.

◆ DL_INSERT_INORDER

#define DL_INSERT_INORDER (   head,
  add,
  cmp 
)    DL_INSERT_INORDER2(head,add,cmp,next)

Definition at line 654 of file utlist.h.

◆ DL_INSERT_INORDER2

#define DL_INSERT_INORDER2 (   head,
  add,
  cmp,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
if (head) { \
DL_LOWER_BOUND(head, _tmp, add, cmp); \
DL_APPEND_ELEM(head, _tmp, add); \
} else { \
(head) = (add); \
(head)->prev = (head); \
(head)->next = NULL; \
} \
} while (0)

Definition at line 657 of file utlist.h.

◆ DL_LOWER_BOUND

#define DL_LOWER_BOUND (   head,
  elt,
  like,
  cmp 
)    DL_LOWER_BOUND2(head,elt,like,cmp,next)

Definition at line 670 of file utlist.h.

◆ DL_LOWER_BOUND2

#define DL_LOWER_BOUND2 (   head,
  elt,
  like,
  cmp,
  next 
)
Value:
do { \
if ((head) == NULL || (cmp(head, like)) >= 0) { \
(elt) = NULL; \
} else { \
for ((elt) = (head); (elt)->next != NULL; (elt) = (elt)->next) { \
if ((cmp((elt)->next, like)) >= 0) { \
break; \
} \
} \
} \
} while (0)

Definition at line 673 of file utlist.h.

◆ DL_PREPEND

#define DL_PREPEND (   head,
  add 
)    DL_PREPEND2(head,add,prev,next)

Definition at line 622 of file utlist.h.

◆ DL_PREPEND2

#define DL_PREPEND2 (   head,
  add,
  prev,
  next 
)
Value:
do { \
(add)->next = (head); \
if (head) { \
(add)->prev = (head)->prev; \
(head)->prev = (add); \
} else { \
(add)->prev = (add); \
} \
(head) = (add); \
} while (0)

Definition at line 625 of file utlist.h.

◆ DL_PREPEND_ELEM

#define DL_PREPEND_ELEM (   head,
  el,
  add 
)    DL_PREPEND_ELEM2(head, el, add, prev, next)

Definition at line 801 of file utlist.h.

◆ DL_PREPEND_ELEM2

#define DL_PREPEND_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
if (el) { \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el); \
(add)->prev = (el)->prev; \
(el)->prev = (add); \
if ((head) == (el)) { \
(head) = (add); \
} else { \
(add)->prev->next = (add); \
} \
} else { \
DL_APPEND2(head, add, prev, next); \
} \
} while (0) \

Definition at line 783 of file utlist.h.

◆ DL_REPLACE_ELEM

#define DL_REPLACE_ELEM (   head,
  el,
  add 
)    DL_REPLACE_ELEM2(head, el, add, prev, next)

Definition at line 780 of file utlist.h.

◆ DL_REPLACE_ELEM2

#define DL_REPLACE_ELEM2 (   head,
  el,
  add,
  prev,
  next 
)
Value:
do { \
assert((head) != NULL); \
assert((el) != NULL); \
assert((add) != NULL); \
if ((head) == (el)) { \
(head) = (add); \
(add)->next = (el)->next; \
if ((el)->next == NULL) { \
(add)->prev = (add); \
} else { \
(add)->prev = (el)->prev; \
(add)->next->prev = (add); \
} \
} else { \
(add)->next = (el)->next; \
(add)->prev = (el)->prev; \
(add)->prev->next = (add); \
if ((el)->next == NULL) { \
(head)->prev = (add); \
} else { \
(add)->next->prev = (add); \
} \
} \
} while (0)

Definition at line 754 of file utlist.h.

◆ DL_SEARCH

#define DL_SEARCH   LL_SEARCH

Definition at line 750 of file utlist.h.

◆ DL_SEARCH2

#define DL_SEARCH2   LL_SEARCH2

Definition at line 752 of file utlist.h.

◆ DL_SEARCH_SCALAR

#define DL_SEARCH_SCALAR   LL_SEARCH_SCALAR

Definition at line 749 of file utlist.h.

◆ DL_SEARCH_SCALAR2

#define DL_SEARCH_SCALAR2   LL_SEARCH_SCALAR2

Definition at line 751 of file utlist.h.

◆ DL_SORT

#define DL_SORT (   list,
  cmp 
)    DL_SORT2(list, cmp, prev, next)

Definition at line 173 of file utlist.h.

◆ DL_SORT2

#define DL_SORT2 (   list,
  cmp,
  prev,
  next 
)

Definition at line 176 of file utlist.h.

◆ IF_NO_DECLTYPE

#define IF_NO_DECLTYPE (   x)

Definition at line 95 of file utlist.h.

◆ LDECLTYPE

#define LDECLTYPE (   x)    __typeof(x)

Definition at line 77 of file utlist.h.

◆ LL_APPEND

#define LL_APPEND (   head,
  add 
)    LL_APPEND2(head,add,next)

Definition at line 339 of file utlist.h.

◆ LL_APPEND2

#define LL_APPEND2 (   head,
  add,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
(add)->next=NULL; \
if (head) { \
_tmp = (head); \
while (_tmp->next) { _tmp = _tmp->next; } \
_tmp->next=(add); \
} else { \
(head)=(add); \
} \
} while (0)

Definition at line 342 of file utlist.h.

◆ LL_APPEND_ELEM

#define LL_APPEND_ELEM (   head,
  el,
  add 
)    LL_APPEND_ELEM2(head, el, add, next)

Definition at line 507 of file utlist.h.

◆ LL_APPEND_ELEM2

#define LL_APPEND_ELEM2 (   head,
  el,
  add,
  next 
)
Value:
do { \
if (el) { \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el)->next; \
(el)->next = (add); \
} else { \
LL_PREPEND2(head, add, next); \
} \
} while (0) \

Definition at line 495 of file utlist.h.

◆ LL_CONCAT

#define LL_CONCAT (   head1,
  head2 
)    LL_CONCAT2(head1,head2,next)

Definition at line 324 of file utlist.h.

◆ LL_CONCAT2

#define LL_CONCAT2 (   head1,
  head2,
  next 
)
Value:
do { \
LDECLTYPE(head1) _tmp; \
if (head1) { \
_tmp = (head1); \
while (_tmp->next) { _tmp = _tmp->next; } \
_tmp->next=(head2); \
} else { \
(head1)=(head2); \
} \
} while (0)

Definition at line 327 of file utlist.h.

◆ LL_COUNT

#define LL_COUNT (   head,
  el,
  counter 
)    LL_COUNT2(head,el,counter,next) \

Definition at line 405 of file utlist.h.

◆ LL_COUNT2

#define LL_COUNT2 (   head,
  el,
  counter,
  next 
)
Value:
do { \
(counter) = 0; \
LL_FOREACH2(head,el,next) { ++(counter); } \
} while (0)

Definition at line 408 of file utlist.h.

◆ LL_DELETE

#define LL_DELETE (   head,
  del 
)    LL_DELETE2(head,del,next)

Definition at line 386 of file utlist.h.

◆ LL_DELETE2

#define LL_DELETE2 (   head,
  del,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
if ((head) == (del)) { \
(head)=(head)->next; \
} else { \
_tmp = (head); \
while (_tmp->next && (_tmp->next != (del))) { \
_tmp = _tmp->next; \
} \
if (_tmp->next) { \
_tmp->next = (del)->next; \
} \
} \
} while (0)

Definition at line 389 of file utlist.h.

◆ LL_FOREACH

#define LL_FOREACH (   head,
  el 
)    LL_FOREACH2(head,el,next)

Definition at line 414 of file utlist.h.

◆ LL_FOREACH2

#define LL_FOREACH2 (   head,
  el,
  next 
)    for ((el) = (head); el; (el) = (el)->next)

Definition at line 417 of file utlist.h.

◆ LL_FOREACH_SAFE

#define LL_FOREACH_SAFE (   head,
  el,
  tmp 
)    LL_FOREACH_SAFE2(head,el,tmp,next)

Definition at line 420 of file utlist.h.

◆ LL_FOREACH_SAFE2

#define LL_FOREACH_SAFE2 (   head,
  el,
  tmp,
  next 
)    for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))

Definition at line 423 of file utlist.h.

◆ LL_INSERT_INORDER

#define LL_INSERT_INORDER (   head,
  add,
  cmp 
)    LL_INSERT_INORDER2(head,add,cmp,next)

Definition at line 355 of file utlist.h.

◆ LL_INSERT_INORDER2

#define LL_INSERT_INORDER2 (   head,
  add,
  cmp,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
if (head) { \
LL_LOWER_BOUND(head, _tmp, add, cmp); \
LL_APPEND_ELEM(head, _tmp, add); \
} else { \
(head) = (add); \
(head)->next = NULL; \
} \
} while (0)

Definition at line 358 of file utlist.h.

◆ LL_LOWER_BOUND

#define LL_LOWER_BOUND (   head,
  elt,
  like,
  cmp 
)    LL_LOWER_BOUND2(head,elt,like,cmp,next)

Definition at line 370 of file utlist.h.

◆ LL_LOWER_BOUND2

#define LL_LOWER_BOUND2 (   head,
  elt,
  like,
  cmp,
  next 
)
Value:
do { \
if ((head) == NULL || (cmp(head, like)) >= 0) { \
(elt) = NULL; \
} else { \
for ((elt) = (head); (elt)->next != NULL; (elt) = (elt)->next) { \
if (cmp((elt)->next, like) >= 0) { \
break; \
} \
} \
} \
} while (0)

Definition at line 373 of file utlist.h.

◆ LL_PREPEND

#define LL_PREPEND (   head,
  add 
)    LL_PREPEND2(head,add,next)

Definition at line 315 of file utlist.h.

◆ LL_PREPEND2

#define LL_PREPEND2 (   head,
  add,
  next 
)
Value:
do { \
(add)->next = (head); \
(head) = (add); \
} while (0)

Definition at line 318 of file utlist.h.

◆ LL_PREPEND_ELEM

#define LL_PREPEND_ELEM (   head,
  el,
  add 
)    LL_PREPEND_ELEM2(head, el, add, next)

Definition at line 492 of file utlist.h.

◆ LL_PREPEND_ELEM2

#define LL_PREPEND_ELEM2 (   head,
  el,
  add,
  next 
)
Value:
do { \
if (el) { \
LDECLTYPE(head) _tmp; \
assert((head) != NULL); \
assert((add) != NULL); \
(add)->next = (el); \
if ((head) == (el)) { \
(head) = (add); \
} else { \
_tmp = (head); \
while (_tmp->next && (_tmp->next != (el))) { \
_tmp = _tmp->next; \
} \
if (_tmp->next) { \
_tmp->next = (add); \
} \
} \
} else { \
LL_APPEND2(head, add, next); \
} \
} while (0) \

Definition at line 469 of file utlist.h.

◆ LL_REPLACE_ELEM

#define LL_REPLACE_ELEM (   head,
  el,
  add 
)    LL_REPLACE_ELEM2(head, el, add, next)

Definition at line 466 of file utlist.h.

◆ LL_REPLACE_ELEM2

#define LL_REPLACE_ELEM2 (   head,
  el,
  add,
  next 
)
Value:
do { \
LDECLTYPE(head) _tmp; \
assert((head) != NULL); \
assert((el) != NULL); \
assert((add) != NULL); \
(add)->next = (el)->next; \
if ((head) == (el)) { \
(head) = (add); \
} else { \
_tmp = (head); \
while (_tmp->next && (_tmp->next != (el))) { \
_tmp = _tmp->next; \
} \
if (_tmp->next) { \
_tmp->next = (add); \
} \
} \
} while (0)

Definition at line 446 of file utlist.h.

◆ LL_SEARCH

#define LL_SEARCH (   head,
  out,
  elt,
  cmp 
)    LL_SEARCH2(head,out,elt,cmp,next)

Definition at line 436 of file utlist.h.

◆ LL_SEARCH2

#define LL_SEARCH2 (   head,
  out,
  elt,
  cmp,
  next 
)
Value:
do { \
LL_FOREACH2(head,out,next) { \
if ((cmp(out,elt))==0) break; \
} \
} while (0)

Definition at line 439 of file utlist.h.

◆ LL_SEARCH_SCALAR

#define LL_SEARCH_SCALAR (   head,
  out,
  field,
  val 
)    LL_SEARCH_SCALAR2(head,out,field,val,next)

Definition at line 426 of file utlist.h.

◆ LL_SEARCH_SCALAR2

#define LL_SEARCH_SCALAR2 (   head,
  out,
  field,
  val,
  next 
)
Value:
do { \
LL_FOREACH2(head,out,next) { \
if ((out)->field == (val)) break; \
} \
} while (0)

Definition at line 429 of file utlist.h.

◆ LL_SORT

#define LL_SORT (   list,
  cmp 
)    LL_SORT2(list, cmp, next)

Definition at line 109 of file utlist.h.

◆ LL_SORT2

#define LL_SORT2 (   list,
  cmp,
  next 
)

Definition at line 112 of file utlist.h.

◆ UTLIST_CASTASGN

#define UTLIST_CASTASGN (   a,
 
)    (a)=(b)

Definition at line 102 of file utlist.h.

◆ UTLIST_NEXT

#define UTLIST_NEXT (   elt,
  list,
  next 
)    ((elt)->next)

Definition at line 97 of file utlist.h.

◆ UTLIST_NEXTASGN

#define UTLIST_NEXTASGN (   elt,
  list,
  to,
  next 
)    ((elt)->next)=(to)

Definition at line 98 of file utlist.h.

◆ UTLIST_PREVASGN

#define UTLIST_PREVASGN (   elt,
  list,
  to,
  prev 
)    ((elt)->prev)=(to)

Definition at line 100 of file utlist.h.

◆ UTLIST_RS

#define UTLIST_RS (   list)

Definition at line 101 of file utlist.h.

◆ UTLIST_SV

#define UTLIST_SV (   elt,
  list 
)

Definition at line 96 of file utlist.h.

◆ UTLIST_VERSION

#define UTLIST_VERSION   2.0.2

Definition at line 28 of file utlist.h.

UT_hash_handle::next
void * next
Definition: uthash.h:1100
UT_hash_handle::prev
void * prev
Definition: uthash.h:1099