|
@@ -0,0 +1,733 @@
|
|
|
|
|
+/*
|
|
|
|
|
+Copyright (c) 2007-2013, Troy D. Hanson http://uthash.sourceforge.net
|
|
|
|
|
+All rights reserved.
|
|
|
|
|
+
|
|
|
|
|
+Redistribution and use in source and binary forms, with or without
|
|
|
|
|
+modification, are permitted provided that the following conditions are met:
|
|
|
|
|
+
|
|
|
|
|
+ * Redistributions of source code must retain the above copyright
|
|
|
|
|
+ notice, this list of conditions and the following disclaimer.
|
|
|
|
|
+
|
|
|
|
|
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
|
|
|
|
|
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
|
|
|
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
|
|
|
|
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
|
|
|
|
|
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
|
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
|
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
|
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
|
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
|
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
|
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
+*/
|
|
|
|
|
+
|
|
|
|
|
+#ifndef UTLIST_H
|
|
|
|
|
+#define UTLIST_H
|
|
|
|
|
+
|
|
|
|
|
+#define UTLIST_VERSION 1.9.7
|
|
|
|
|
+
|
|
|
|
|
+#include <assert.h>
|
|
|
|
|
+
|
|
|
|
|
+/*
|
|
|
|
|
+ * This file contains macros to manipulate singly and doubly-linked lists.
|
|
|
|
|
+ *
|
|
|
|
|
+ * 1. LL_ macros: singly-linked lists.
|
|
|
|
|
+ * 2. DL_ macros: doubly-linked lists.
|
|
|
|
|
+ * 3. CDL_ macros: circular doubly-linked lists.
|
|
|
|
|
+ *
|
|
|
|
|
+ * To use singly-linked lists, your structure must have a "next" pointer.
|
|
|
|
|
+ * To use doubly-linked lists, your structure must "prev" and "next" pointers.
|
|
|
|
|
+ * Either way, the pointer to the head of the list must be initialized to NULL.
|
|
|
|
|
+ *
|
|
|
|
|
+ * ----------------.EXAMPLE -------------------------
|
|
|
|
|
+ * struct item {
|
|
|
|
|
+ * int id;
|
|
|
|
|
+ * struct item *prev, *next;
|
|
|
|
|
+ * }
|
|
|
|
|
+ *
|
|
|
|
|
+ * struct item *list = NULL:
|
|
|
|
|
+ *
|
|
|
|
|
+ * int main() {
|
|
|
|
|
+ * struct item *item;
|
|
|
|
|
+ * ... allocate and populate item ...
|
|
|
|
|
+ * DL_APPEND(list, item);
|
|
|
|
|
+ * }
|
|
|
|
|
+ * --------------------------------------------------
|
|
|
|
|
+ *
|
|
|
|
|
+ * For doubly-linked lists, the append and delete macros are O(1)
|
|
|
|
|
+ * For singly-linked lists, append and delete are O(n) but prepend is O(1)
|
|
|
|
|
+ * The sort macro is O(n log(n)) for all types of single/double/circular lists.
|
|
|
|
|
+ */
|
|
|
|
|
+
|
|
|
|
|
+/* These macros use decltype or the earlier __typeof GNU extension.
|
|
|
|
|
+ As decltype is only available in newer compilers (VS2010 or gcc 4.3+
|
|
|
|
|
+ when compiling c++ code), this code uses whatever method is needed
|
|
|
|
|
+ or, for VS2008 where neither is available, uses casting workarounds. */
|
|
|
|
|
+#ifdef _MSC_VER /* MS compiler */
|
|
|
|
|
+#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */
|
|
|
|
|
+#define LDECLTYPE(x) decltype(x)
|
|
|
|
|
+#else /* VS2008 or older (or VS2010 in C mode) */
|
|
|
|
|
+#define NO_DECLTYPE
|
|
|
|
|
+#define LDECLTYPE(x) char*
|
|
|
|
|
+#endif
|
|
|
|
|
+#else /* GNU, Sun and other compilers */
|
|
|
|
|
+#define LDECLTYPE(x) __typeof(x)
|
|
|
|
|
+#endif
|
|
|
|
|
+
|
|
|
|
|
+/* for VS2008 we use some workarounds to get around the lack of decltype,
|
|
|
|
|
+ * namely, we always reassign our tmp variable to the list head if we need
|
|
|
|
|
+ * to dereference its prev/next pointers, and save/restore the real head.*/
|
|
|
|
|
+#ifdef NO_DECLTYPE
|
|
|
|
|
+#define _SV(elt,list) _tmp = (char*)(list); {char **_alias = (char**)&(list); *_alias = (elt); }
|
|
|
|
|
+#define _NEXT(elt,list,next) ((char*)((list)->next))
|
|
|
|
|
+#define _NEXTASGN(elt,list,to,next) { char **_alias = (char**)&((list)->next); *_alias=(char*)(to); }
|
|
|
|
|
+/* #define _PREV(elt,list,prev) ((char*)((list)->prev)) */
|
|
|
|
|
+#define _PREVASGN(elt,list,to,prev) { char **_alias = (char**)&((list)->prev); *_alias=(char*)(to); }
|
|
|
|
|
+#define _RS(list) { char **_alias = (char**)&(list); *_alias=_tmp; }
|
|
|
|
|
+#define _CASTASGN(a,b) { char **_alias = (char**)&(a); *_alias=(char*)(b); }
|
|
|
|
|
+#else
|
|
|
|
|
+#define _SV(elt,list)
|
|
|
|
|
+#define _NEXT(elt,list,next) ((elt)->next)
|
|
|
|
|
+#define _NEXTASGN(elt,list,to,next) ((elt)->next)=(to)
|
|
|
|
|
+/* #define _PREV(elt,list,prev) ((elt)->prev) */
|
|
|
|
|
+#define _PREVASGN(elt,list,to,prev) ((elt)->prev)=(to)
|
|
|
|
|
+#define _RS(list)
|
|
|
|
|
+#define _CASTASGN(a,b) (a)=(b)
|
|
|
|
|
+#endif
|
|
|
|
|
+
|
|
|
|
|
+/******************************************************************************
|
|
|
|
|
+ * The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort *
|
|
|
|
|
+ * Unwieldy variable names used here to avoid shadowing passed-in variables. *
|
|
|
|
|
+ *****************************************************************************/
|
|
|
|
|
+#define LL_SORT(list, cmp) \
|
|
|
|
|
+ LL_SORT2(list, cmp, next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_SORT2(list, cmp, next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LDECLTYPE(list) _ls_p; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_q; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_e; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_tail; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_oldhead; \
|
|
|
|
|
+ LDECLTYPE(list) _tmp; \
|
|
|
|
|
+ int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
|
|
|
|
|
+ if (list) { \
|
|
|
|
|
+ _ls_insize = 1; \
|
|
|
|
|
+ _ls_looping = 1; \
|
|
|
|
|
+ while (_ls_looping) { \
|
|
|
|
|
+ _CASTASGN(_ls_p,list); \
|
|
|
|
|
+ _CASTASGN(_ls_oldhead,list); \
|
|
|
|
|
+ list = NULL; \
|
|
|
|
|
+ _ls_tail = NULL; \
|
|
|
|
|
+ _ls_nmerges = 0; \
|
|
|
|
|
+ while (_ls_p) { \
|
|
|
|
|
+ _ls_nmerges++; \
|
|
|
|
|
+ _ls_q = _ls_p; \
|
|
|
|
|
+ _ls_psize = 0; \
|
|
|
|
|
+ for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \
|
|
|
|
|
+ _ls_psize++; \
|
|
|
|
|
+ _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); \
|
|
|
|
|
+ if (!_ls_q) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_qsize = _ls_insize; \
|
|
|
|
|
+ while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \
|
|
|
|
|
+ if (_ls_psize == 0) { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ } else if (_ls_qsize == 0 || !_ls_q) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ } else if (cmp(_ls_p,_ls_q) <= 0) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ if (_ls_tail) { \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _CASTASGN(list,_ls_e); \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_tail = _ls_e; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_p = _ls_q; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); \
|
|
|
|
|
+ if (_ls_nmerges <= 1) { \
|
|
|
|
|
+ _ls_looping=0; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_insize *= 2; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ } else _tmp=NULL; /* quiet gcc unused variable warning */ \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+
|
|
|
|
|
+#define DL_SORT(list, cmp) \
|
|
|
|
|
+ DL_SORT2(list, cmp, prev, next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_SORT2(list, cmp, prev, next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LDECLTYPE(list) _ls_p; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_q; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_e; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_tail; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_oldhead; \
|
|
|
|
|
+ LDECLTYPE(list) _tmp; \
|
|
|
|
|
+ int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
|
|
|
|
|
+ if (list) { \
|
|
|
|
|
+ _ls_insize = 1; \
|
|
|
|
|
+ _ls_looping = 1; \
|
|
|
|
|
+ while (_ls_looping) { \
|
|
|
|
|
+ _CASTASGN(_ls_p,list); \
|
|
|
|
|
+ _CASTASGN(_ls_oldhead,list); \
|
|
|
|
|
+ list = NULL; \
|
|
|
|
|
+ _ls_tail = NULL; \
|
|
|
|
|
+ _ls_nmerges = 0; \
|
|
|
|
|
+ while (_ls_p) { \
|
|
|
|
|
+ _ls_nmerges++; \
|
|
|
|
|
+ _ls_q = _ls_p; \
|
|
|
|
|
+ _ls_psize = 0; \
|
|
|
|
|
+ for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \
|
|
|
|
|
+ _ls_psize++; \
|
|
|
|
|
+ _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); \
|
|
|
|
|
+ if (!_ls_q) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_qsize = _ls_insize; \
|
|
|
|
|
+ while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \
|
|
|
|
|
+ if (_ls_psize == 0) { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ } else if (_ls_qsize == 0 || !_ls_q) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ } else if (cmp(_ls_p,_ls_q) <= 0) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ if (_ls_tail) { \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _CASTASGN(list,_ls_e); \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); \
|
|
|
|
|
+ _ls_tail = _ls_e; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_p = _ls_q; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _CASTASGN(list->prev, _ls_tail); \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); \
|
|
|
|
|
+ if (_ls_nmerges <= 1) { \
|
|
|
|
|
+ _ls_looping=0; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_insize *= 2; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ } else _tmp=NULL; /* quiet gcc unused variable warning */ \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_SORT(list, cmp) \
|
|
|
|
|
+ CDL_SORT2(list, cmp, prev, next)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_SORT2(list, cmp, prev, next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LDECLTYPE(list) _ls_p; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_q; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_e; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_tail; \
|
|
|
|
|
+ LDECLTYPE(list) _ls_oldhead; \
|
|
|
|
|
+ LDECLTYPE(list) _tmp; \
|
|
|
|
|
+ LDECLTYPE(list) _tmp2; \
|
|
|
|
|
+ int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
|
|
|
|
|
+ if (list) { \
|
|
|
|
|
+ _ls_insize = 1; \
|
|
|
|
|
+ _ls_looping = 1; \
|
|
|
|
|
+ while (_ls_looping) { \
|
|
|
|
|
+ _CASTASGN(_ls_p,list); \
|
|
|
|
|
+ _CASTASGN(_ls_oldhead,list); \
|
|
|
|
|
+ list = NULL; \
|
|
|
|
|
+ _ls_tail = NULL; \
|
|
|
|
|
+ _ls_nmerges = 0; \
|
|
|
|
|
+ while (_ls_p) { \
|
|
|
|
|
+ _ls_nmerges++; \
|
|
|
|
|
+ _ls_q = _ls_p; \
|
|
|
|
|
+ _ls_psize = 0; \
|
|
|
|
|
+ for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \
|
|
|
|
|
+ _ls_psize++; \
|
|
|
|
|
+ _SV(_ls_q,list); \
|
|
|
|
|
+ if (_NEXT(_ls_q,list,next) == _ls_oldhead) { \
|
|
|
|
|
+ _ls_q = NULL; \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _ls_q = _NEXT(_ls_q,list,next); \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _RS(list); \
|
|
|
|
|
+ if (!_ls_q) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_qsize = _ls_insize; \
|
|
|
|
|
+ while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \
|
|
|
|
|
+ if (_ls_psize == 0) { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ if (_ls_q == _ls_oldhead) { _ls_q = NULL; } \
|
|
|
|
|
+ } else if (_ls_qsize == 0 || !_ls_q) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ if (_ls_p == _ls_oldhead) { _ls_p = NULL; } \
|
|
|
|
|
+ } else if (cmp(_ls_p,_ls_q) <= 0) { \
|
|
|
|
|
+ _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \
|
|
|
|
|
+ _NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \
|
|
|
|
|
+ if (_ls_p == _ls_oldhead) { _ls_p = NULL; } \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \
|
|
|
|
|
+ _NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \
|
|
|
|
|
+ if (_ls_q == _ls_oldhead) { _ls_q = NULL; } \
|
|
|
|
|
+ } \
|
|
|
|
|
+ if (_ls_tail) { \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ _CASTASGN(list,_ls_e); \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); \
|
|
|
|
|
+ _ls_tail = _ls_e; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_p = _ls_q; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _CASTASGN(list->prev,_ls_tail); \
|
|
|
|
|
+ _CASTASGN(_tmp2,list); \
|
|
|
|
|
+ _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp2,next); _RS(list); \
|
|
|
|
|
+ if (_ls_nmerges <= 1) { \
|
|
|
|
|
+ _ls_looping=0; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ _ls_insize *= 2; \
|
|
|
|
|
+ } \
|
|
|
|
|
+ } else _tmp=NULL; /* quiet gcc unused variable warning */ \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+/******************************************************************************
|
|
|
|
|
+ * singly linked list macros (non-circular) *
|
|
|
|
|
+ *****************************************************************************/
|
|
|
|
|
+#define LL_PREPEND(head,add) \
|
|
|
|
|
+ LL_PREPEND2(head,add,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_PREPEND2(head,add,next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ (add)->next = head; \
|
|
|
|
|
+ head = add; \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_CONCAT(head1,head2) \
|
|
|
|
|
+ LL_CONCAT2(head1,head2,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_CONCAT2(head1,head2,next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LDECLTYPE(head1) _tmp; \
|
|
|
|
|
+ if (head1) { \
|
|
|
|
|
+ _tmp = head1; \
|
|
|
|
|
+ while (_tmp->next) { _tmp = _tmp->next; } \
|
|
|
|
|
+ _tmp->next=(head2); \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ (head1)=(head2); \
|
|
|
|
|
+ } \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_APPEND(head,add) \
|
|
|
|
|
+ LL_APPEND2(head,add,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_APPEND2(head,add,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_DELETE(head,del) \
|
|
|
|
|
+ LL_DELETE2(head,del,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_DELETE2(head,del,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+/* Here are VS2008 replacements for LL_APPEND and LL_DELETE */
|
|
|
|
|
+#define LL_APPEND_VS2008(head,add) \
|
|
|
|
|
+ LL_APPEND2_VS2008(head,add,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_APPEND2_VS2008(head,add,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_DELETE_VS2008(head,del) \
|
|
|
|
|
+ LL_DELETE2_VS2008(head,del,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_DELETE2_VS2008(head,del,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+#ifdef NO_DECLTYPE
|
|
|
|
|
+#undef LL_APPEND
|
|
|
|
|
+#define LL_APPEND LL_APPEND_VS2008
|
|
|
|
|
+#undef LL_DELETE
|
|
|
|
|
+#define LL_DELETE LL_DELETE_VS2008
|
|
|
|
|
+#undef LL_DELETE2
|
|
|
|
|
+#define LL_DELETE2_VS2008
|
|
|
|
|
+#undef LL_APPEND2
|
|
|
|
|
+#define LL_APPEND2 LL_APPEND2_VS2008
|
|
|
|
|
+#undef LL_CONCAT /* no LL_CONCAT_VS2008 */
|
|
|
|
|
+#undef DL_CONCAT /* no DL_CONCAT_VS2008 */
|
|
|
|
|
+#endif
|
|
|
|
|
+/* end VS2008 replacements */
|
|
|
|
|
+
|
|
|
|
|
+#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) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LL_FOREACH2(head,out,next) { \
|
|
|
|
|
+ if ((out)->field == (val)) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+} while(0)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_SEARCH(head,out,elt,cmp) \
|
|
|
|
|
+ LL_SEARCH2(head,out,elt,cmp,next)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_SEARCH2(head,out,elt,cmp,next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ LL_FOREACH2(head,out,next) { \
|
|
|
|
|
+ if ((cmp(out,elt))==0) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+} while(0)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_REPLACE_ELEM(head, el, add) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define LL_PREPEND_ELEM(head, el, add) \
|
|
|
|
|
+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) \
|
|
|
|
|
+
|
|
|
|
|
+
|
|
|
|
|
+/******************************************************************************
|
|
|
|
|
+ * doubly linked list macros (non-circular) *
|
|
|
|
|
+ *****************************************************************************/
|
|
|
|
|
+#define DL_PREPEND(head,add) \
|
|
|
|
|
+ DL_PREPEND2(head,add,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_PREPEND2(head,add,prev,next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ (add)->next = head; \
|
|
|
|
|
+ if (head) { \
|
|
|
|
|
+ (add)->prev = (head)->prev; \
|
|
|
|
|
+ (head)->prev = (add); \
|
|
|
|
|
+ } else { \
|
|
|
|
|
+ (add)->prev = (add); \
|
|
|
|
|
+ } \
|
|
|
|
|
+ (head) = (add); \
|
|
|
|
|
+} while (0)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_APPEND(head,add) \
|
|
|
|
|
+ DL_APPEND2(head,add,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_APPEND2(head,add,prev,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_CONCAT(head1,head2) \
|
|
|
|
|
+ DL_CONCAT2(head1,head2,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_CONCAT2(head1,head2,prev,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_DELETE(head,del) \
|
|
|
|
|
+ DL_DELETE2(head,del,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_DELETE2(head,del,prev,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+
|
|
|
|
|
+#define DL_FOREACH(head,el) \
|
|
|
|
|
+ DL_FOREACH2(head,el,next)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_FOREACH2(head,el,next) \
|
|
|
|
|
+ for(el=head;el;el=(el)->next)
|
|
|
|
|
+
|
|
|
|
|
+/* this version is safe for deleting the elements during iteration */
|
|
|
|
|
+#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)
|
|
|
|
|
+
|
|
|
|
|
+/* these are identical to their singly-linked list counterparts */
|
|
|
|
|
+#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) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define DL_PREPEND_ELEM(head, el, add) \
|
|
|
|
|
+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) \
|
|
|
|
|
+
|
|
|
|
|
+
|
|
|
|
|
+/******************************************************************************
|
|
|
|
|
+ * circular doubly linked list macros *
|
|
|
|
|
+ *****************************************************************************/
|
|
|
|
|
+#define CDL_PREPEND(head,add) \
|
|
|
|
|
+ CDL_PREPEND2(head,add,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_PREPEND2(head,add,prev,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_DELETE(head,del) \
|
|
|
|
|
+ CDL_DELETE2(head,del,prev,next)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_DELETE2(head,del,prev,next) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#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) \
|
|
|
|
|
+ for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL); \
|
|
|
|
|
+ (el) && ((tmp2)=(el)->next, 1); \
|
|
|
|
|
+ ((el) = (((el)==(tmp1)) ? 0L : (tmp2))))
|
|
|
|
|
+
|
|
|
|
|
+#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) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ CDL_FOREACH2(head,out,next) { \
|
|
|
|
|
+ if ((out)->field == (val)) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+} while(0)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_SEARCH(head,out,elt,cmp) \
|
|
|
|
|
+ CDL_SEARCH2(head,out,elt,cmp,next)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_SEARCH2(head,out,elt,cmp,next) \
|
|
|
|
|
+do { \
|
|
|
|
|
+ CDL_FOREACH2(head,out,next) { \
|
|
|
|
|
+ if ((cmp(out,elt))==0) break; \
|
|
|
|
|
+ } \
|
|
|
|
|
+} while(0)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_REPLACE_ELEM(head, el, add) \
|
|
|
|
|
+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)
|
|
|
|
|
+
|
|
|
|
|
+#define CDL_PREPEND_ELEM(head, el, add) \
|
|
|
|
|
+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) \
|
|
|
|
|
+
|
|
|
|
|
+#endif /* UTLIST_H */
|
|
|
|
|
+
|
Luke Dashjr