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 1.9.9
#define | LDECLTYPE(x) __typeof(x)
#define | _SV(elt, list)
#define | _NEXT(elt, list, next) ((elt)->next)
#define | _NEXTASGN(elt, list, to, next) ((elt)->next)=(to)
#define | _PREVASGN(elt, list, to, prev) ((elt)->prev)=(to)
#define | _RS(list)
#define | _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_DELETE(head, del) LL_DELETE2(head,del,next)
#define | LL_DELETE2(head, del, next)
#define | LL_APPEND_VS2008(head, add) LL_APPEND2_VS2008(head,add,next)
#define | LL_APPEND2_VS2008(head, add, next)
#define | LL_DELETE_VS2008(head, del) LL_DELETE2_VS2008(head,del,next)
#define | LL_DELETE2_VS2008(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_ELEM(head, el, add)
#define | LL_PREPEND_ELEM(head, el, add)
#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_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_ELEM(head, el, add)
#define | DL_PREPEND_ELEM(head, el, add)
#define | CDL_PREPEND(head, add) CDL_PREPEND2(head,add,prev,next)
#define | CDL_PREPEND2(head, add, prev, 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 ? 0L : (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_ELEM(head, el, add)
#define | CDL_PREPEND_ELEM(head, el, add)

## Macro Definition Documentation

## _CASTASGN

#define _CASTASGN | ( |  | a,
|  |  | b
| ) |  | (a)=(b)

Definition at line 98 of file utlist.h.

## _NEXT

#define _NEXT | ( |  | elt,
|  |  | list,
|  |  | next
| ) |  | ((elt)->next)

Definition at line 93 of file utlist.h.

## _NEXTASGN

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

Definition at line 94 of file utlist.h.

## _PREVASGN

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

Definition at line 96 of file utlist.h.

## _RS

#define _RS | ( |  | list | ) |

Definition at line 97 of file utlist.h.

## _SV

#define _SV | ( |  | elt,
|  |  | list
| ) |  |

Definition at line 92 of file utlist.h.

## CDL_COUNT

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

Definition at line 679 of file utlist.h.

## CDL_COUNT2

#define CDL_COUNT2 | ( |  | head,
|  |  | el,
|  |  | counter,
|  |  | next
| ) |  |

Value:
{ \
counter = 0; \
CDL_FOREACH2(head,el,next){ ++counter; } \
}
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 682 of file utlist.h.

## CDL_DELETE

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

Definition at line 665 of file utlist.h.

## CDL_DELETE2

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

Value:
do { \
if ( ((head)==(del)) && ((head)->next == (head))) { \
(head) = 0L; \
} else { \
(del)->next->prev = (del)->prev; \
(del)->prev->next = (del)->next; \
if ((del) == (head)) (head)=(del)->next; \
} \
} while (0)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 668 of file utlist.h.

## CDL_FOREACH

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

Definition at line 688 of file utlist.h.

## CDL_FOREACH2

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

Definition at line 691 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 694 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)) ? 0L : (tmp2))))
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 697 of file utlist.h.

## CDL_PREPEND

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

Definition at line 648 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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 651 of file utlist.h.

## CDL_PREPEND_ELEM

#define CDL_PREPEND_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

Value:
do { \
assert(head != NULL); \
assert(el != NULL); \
assert(add != NULL); \
(add)->next = (el); \
(add)->prev = (el)->prev; \
(el)->prev = (add); \
(add)->prev->next = (add); \
if ((head) == (el)) { \
(head) = (add); \
} \
} while (0) \
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 742 of file utlist.h.

## CDL_REPLACE_ELEM

#define CDL_REPLACE_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 722 of file utlist.h.

## CDL_SEARCH

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

Definition at line 712 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 715 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 702 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 705 of file utlist.h.

## CDL_SORT

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

Definition at line 230 of file utlist.h.

## CDL_SORT2

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

Definition at line 233 of file utlist.h.

## DL_APPEND

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

Definition at line 519 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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 522 of file utlist.h.

## DL_CONCAT

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

Definition at line 536 of file utlist.h.

## DL_CONCAT2

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

Value:
do { \
LDECLTYPE(head1) _tmp; \
if (head2) { \
if (head1) { \
_tmp = (head2)->prev; \
(head2)->prev = (head1)->prev; \
(head1)->prev->next = (head2); \
(head1)->prev = _tmp; \
} else { \
(head1)=(head2); \
} \
} \
} while (0)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954

Definition at line 539 of file utlist.h.

## DL_COUNT

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

Definition at line 575 of file utlist.h.

## DL_COUNT2

#define DL_COUNT2 | ( |  | head,
|  |  | el,
|  |  | counter,
|  |  | next
| ) |  |

Value:
{ \
counter = 0; \
DL_FOREACH2(head,el,next){ ++counter; } \
}
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 578 of file utlist.h.

## DL_DELETE

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

Definition at line 554 of file utlist.h.

## DL_DELETE2

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

Value:
do { \
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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 557 of file utlist.h.

## DL_FOREACH

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

Definition at line 584 of file utlist.h.

## DL_FOREACH2

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

Definition at line 587 of file utlist.h.

## DL_FOREACH_SAFE

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

Definition at line 591 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 594 of file utlist.h.

## DL_PREPEND

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

Definition at line 504 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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 507 of file utlist.h.

## DL_PREPEND_ELEM

#define DL_PREPEND_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

Value:
do { \
assert(head != NULL); \
assert(el != NULL); \
assert(add != NULL); \
(add)->next = (el); \
(add)->prev = (el)->prev; \
(el)->prev = (add); \
if ((head) == (el)) { \
(head) = (add); \
} else { \
(add)->prev->next = (add); \
} \
} while (0) \
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 629 of file utlist.h.

## DL_REPLACE_ELEM

#define DL_REPLACE_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

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)
UT_hash_handle::prev
void * prev
Definition: uthash.h:954
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 603 of file utlist.h.

## DL_SEARCH

#define DL_SEARCH LL_SEARCH

Definition at line 599 of file utlist.h.

## DL_SEARCH2

#define DL_SEARCH2 LL_SEARCH2

Definition at line 601 of file utlist.h.

## DL_SEARCH_SCALAR

#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR

Definition at line 598 of file utlist.h.

## DL_SEARCH_SCALAR2

#define DL_SEARCH_SCALAR2 LL_SEARCH_SCALAR2

Definition at line 600 of file utlist.h.

## DL_SORT

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

Definition at line 168 of file utlist.h.

## DL_SORT2

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

Definition at line 171 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 333 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 336 of file utlist.h.

## LL_APPEND2_VS2008

#define LL_APPEND2_VS2008 | ( |  | head,
|  |  | add,
|  |  | next
| ) |  |

Value:
do { \
if (head) { \
(add)->next = head; /* use add->next as a temp variable */ \
while ((add)->next->next) { (add)->next = (add)->next->next; } \
(add)->next->next=(add); \
} else { \
(head)=(add); \
} \
(add)->next=NULL; \
} while (0)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 372 of file utlist.h.

## LL_APPEND_VS2008

#define LL_APPEND_VS2008 | ( |  | head,
|  |  | add
| ) |  | LL_APPEND2_VS2008(head,add,next)

Definition at line 369 of file utlist.h.

## LL_CONCAT

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

Definition at line 318 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 321 of file utlist.h.

## LL_COUNT

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

Definition at line 419 of file utlist.h.

## LL_COUNT2

#define LL_COUNT2 | ( |  | head,
|  |  | el,
|  |  | counter,
|  |  | next
| ) |  |

Value:
{ \
counter = 0; \
LL_FOREACH2(head,el,next){ ++counter; } \
}
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 422 of file utlist.h.

## LL_DELETE

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

Definition at line 349 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 352 of file utlist.h.

## LL_DELETE2_VS2008

#define LL_DELETE2_VS2008 | ( |  | head,
|  |  | del,
|  |  | next
| ) |  |

Value:
do { \
if ((head) == (del)) { \
(head)=(head)->next; \
} else { \
char *_tmp = (char*)(head); \
while ((head)->next && ((head)->next != (del))) { \
head = (head)->next; \
} \
if ((head)->next) { \
(head)->next = ((del)->next); \
} \
{ \
char **_head_alias = (char**)&(head); \
*_head_alias = _tmp; \
} \
} \
} while (0)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 387 of file utlist.h.

## LL_DELETE_VS2008

#define LL_DELETE_VS2008 | ( |  | head,
|  |  | del
| ) |  | LL_DELETE2_VS2008(head,del,next)

Definition at line 384 of file utlist.h.

## LL_FOREACH

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

Definition at line 428 of file utlist.h.

## LL_FOREACH2

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

Definition at line 431 of file utlist.h.

## LL_FOREACH_SAFE

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

Definition at line 434 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 437 of file utlist.h.

## LL_PREPEND

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

Definition at line 309 of file utlist.h.

## LL_PREPEND2

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

Value:
do { \
(add)->next = head; \
head = add; \
} while (0)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 312 of file utlist.h.

## LL_PREPEND_ELEM

#define LL_PREPEND_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

Value:
do { \
LDECLTYPE(head) _tmp; \
assert(head != NULL); \
assert(el != 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); \
} \
} \
} while (0) \
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 480 of file utlist.h.

## LL_REPLACE_ELEM

#define LL_REPLACE_ELEM | ( |  | head,
|  |  | el,
|  |  | add
| ) |  |

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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 460 of file utlist.h.

## LL_SEARCH

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

Definition at line 450 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 453 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 440 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)
UT_hash_handle::next
void * next
Definition: uthash.h:955

Definition at line 443 of file utlist.h.

## LL_SORT

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

Definition at line 105 of file utlist.h.

## LL_SORT2

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

Definition at line 108 of file utlist.h.

## UTLIST_VERSION

#define UTLIST_VERSION 1.9.9

Definition at line 27 of file utlist.h.