ilist.h File Reference (original) (raw)

Go to the source code of this file.

Data Structures
struct	dlist_node

struct	dlist_head

struct	dlist_iter

struct	dlist_mutable_iter

struct	dclist_head

struct	slist_node

struct	slist_head

struct	slist_iter

struct	slist_mutable_iter

Macros
#define	DLIST_STATIC_INIT(name) {{&(name).head, &(name).head}}

#define	DCLIST_STATIC_INIT(name) {{{&(name).dlist.head, &(name).dlist.head}}, 0}

#define	SLIST_STATIC_INIT(name) {{NULL}}

#define	dlist_member_check(head, node) ((void) (head))

#define	dlist_check(head) ((void) (head))

#define	slist_check(head) ((void) (head))

#define	dlist_container(type, membername, ptr)

#define	dlist_head_element(type, membername, lhead)

#define	dlist_tail_element(type, membername, lhead)

#define	dlist_foreach(iter, lhead)

#define	dlist_foreach_modify(iter, lhead)

#define	dlist_reverse_foreach(iter, lhead)

#define	dclist_container(type, membername, ptr) dlist_container(type, membername, ptr)

#define	dclist_head_element(type, membername, lhead)

#define	dclist_tail_element(type, membername, lhead)

#define	dclist_foreach(iter, lhead) dlist_foreach(iter, &((lhead)->dlist))

#define	dclist_foreach_modify(iter, lhead) dlist_foreach_modify(iter, &((lhead)->dlist))

#define	dclist_reverse_foreach(iter, lhead) dlist_reverse_foreach(iter, &((lhead)->dlist))

#define	slist_container(type, membername, ptr)

#define	slist_head_element(type, membername, lhead)

#define	slist_foreach(iter, lhead)

#define	slist_foreach_modify(iter, lhead)

Typedefs
typedef struct dlist_node	dlist_node

typedef struct dlist_head	dlist_head

typedef struct dlist_iter	dlist_iter

typedef struct dlist_mutable_iter	dlist_mutable_iter

typedef struct dclist_head	dclist_head

typedef struct slist_node	slist_node

typedef struct slist_head	slist_head

typedef struct slist_iter	slist_iter

typedef struct slist_mutable_iter	slist_mutable_iter

Functions
void	slist_delete (slist_head head, const slist_node node)

static void	dlist_init (dlist_head *head)

static void	dlist_node_init (dlist_node *node)

static bool	dlist_is_empty (const dlist_head *head)

static void	dlist_push_head (dlist_head head, dlist_node node)

static void	dlist_push_tail (dlist_head head, dlist_node node)

static void	dlist_insert_after (dlist_node after, dlist_node node)

static void	dlist_insert_before (dlist_node before, dlist_node node)

static void	dlist_delete (dlist_node *node)

static void	dlist_delete_thoroughly (dlist_node *node)

static void	dlist_delete_from (dlist_head head, dlist_node node)

static void	dlist_delete_from_thoroughly (dlist_head head, dlist_node node)

static dlist_node *	dlist_pop_head_node (dlist_head *head)

static void	dlist_move_head (dlist_head head, dlist_node node)

static void	dlist_move_tail (dlist_head head, dlist_node node)

static bool	dlist_has_next (const dlist_head head, const dlist_node node)

static bool	dlist_has_prev (const dlist_head head, const dlist_node node)

static bool	dlist_node_is_detached (const dlist_node *node)

static dlist_node *	dlist_next_node (dlist_head head, dlist_node node)

static dlist_node *	dlist_prev_node (dlist_head head, dlist_node node)

static void *	dlist_head_element_off (dlist_head *head, size_t off)

static dlist_node *	dlist_head_node (dlist_head *head)

static void *	dlist_tail_element_off (dlist_head *head, size_t off)

static dlist_node *	dlist_tail_node (dlist_head *head)

static void	dclist_init (dclist_head *head)

static bool	dclist_is_empty (const dclist_head *head)

static void	dclist_push_head (dclist_head head, dlist_node node)

static void	dclist_push_tail (dclist_head head, dlist_node node)

static void	dclist_insert_after (dclist_head head, dlist_node after, dlist_node *node)

static void	dclist_insert_before (dclist_head head, dlist_node before, dlist_node *node)

static void	dclist_delete_from (dclist_head head, dlist_node node)

static void	dclist_delete_from_thoroughly (dclist_head head, dlist_node node)

static dlist_node *	dclist_pop_head_node (dclist_head *head)

static void	dclist_move_head (dclist_head head, dlist_node node)

static void	dclist_move_tail (dclist_head head, dlist_node node)

static bool	dclist_has_next (const dclist_head head, const dlist_node node)

static bool	dclist_has_prev (const dclist_head head, const dlist_node node)

static dlist_node *	dclist_next_node (dclist_head head, dlist_node node)

static dlist_node *	dclist_prev_node (dclist_head head, dlist_node node)

static void *	dclist_head_element_off (dclist_head *head, size_t off)

static dlist_node *	dclist_head_node (dclist_head *head)

static void *	dclist_tail_element_off (dclist_head *head, size_t off)

static dlist_node *	dclist_tail_node (dclist_head *head)

static uint32	dclist_count (const dclist_head *head)

static void	slist_init (slist_head *head)

static bool	slist_is_empty (const slist_head *head)

static void	slist_push_head (slist_head head, slist_node node)

static void	slist_insert_after (slist_node after, slist_node node)

static slist_node *	slist_pop_head_node (slist_head *head)

static bool	slist_has_next (const slist_head head, const slist_node node)

static slist_node *	slist_next_node (slist_head head, slist_node node)

static void *	slist_head_element_off (slist_head *head, size_t off)

static slist_node *	slist_head_node (slist_head *head)

static void	slist_delete_current (slist_mutable_iter *iter)

◆ dclist_container

Definition at line 947 of file ilist.h.

986{

987 head->head.next = NULL;

988}

989

990

991

992

993static inline bool

995{

997

999}

1000

1001

1002

1003

1004static inline void

1006{

1009

1011}

1012

1013

1014

1015

1016static inline void

1018{

1021}

1022

1023

1024

1025

1028{

1030

1035 return node;

1036}

1037

1038

1039

1040

1041static inline bool

1043{

1045

1047}

1048

1049

1050

1051

1054{

1056 return node->next;

1057}

1058

1059

1060static inline void *

1062{

1064 return (char *) head->head.next - off;

1065}

1066

1067

1068

1069

1072{

1074}

1075

1076

1077

1078

1079

1080

1081

1082static inline void

1084{

1085

1086

1087

1088

1089

1091

1092

1093

1094

1095

1097}

1098

1099

1100

1101

1102

1103

1104

1105#define slist_container(type, membername, ptr) \

1106 (StaticAssertVariableIsOfTypeMacro(ptr, slist_node *), \

1107 StaticAssertVariableIsOfTypeMacro(((type *) NULL)->membername, slist_node), \

1108 ((type *) ((char *) (ptr) - offsetof(type, membername))))

1109

1110

1111

1112

1113

1114

1115#define slist_head_element(type, membername, lhead) \

1116 (StaticAssertVariableIsOfTypeMacro(((type *) NULL)->membername, slist_node), \

1117 (type *) slist_head_element_off(lhead, offsetof(type, membername)))

1118

1119

1120

1121

1122

1123

1124

1125

1126

1127

1128

1129

1130

1131#define slist_foreach(iter, lhead) \

1132 for (StaticAssertVariableIsOfTypeMacro(iter, slist_iter), \

1133 StaticAssertVariableIsOfTypeMacro(lhead, slist_head *), \

1134 (iter).cur = (lhead)->head.next; \

1135 (iter).cur != NULL; \

1136 (iter).cur = (iter).cur->next)

1137

1138

1139

1140

1141

1142

1143

1144

1145

1146

1147#define slist_foreach_modify(iter, lhead) \

1148 for (StaticAssertVariableIsOfTypeMacro(iter, slist_mutable_iter), \

1149 StaticAssertVariableIsOfTypeMacro(lhead, slist_head *), \

1150 (iter).prev = &(lhead)->head, \

1151 (iter).cur = (iter).prev->next, \

1152 (iter).next = (iter).cur ? (iter).cur->next : NULL; \

1153 (iter).cur != NULL; \

1154 (iter).prev = (iter).cur, \

1155 (iter).cur = (iter).next, \

1156 (iter).next = (iter).next ? (iter).next->next : NULL)

1157

1158#endif

#define Assert(condition)

static void slist_delete_current(slist_mutable_iter *iter)

static void * slist_head_element_off(slist_head *head, size_t off)

static bool slist_is_empty(const slist_head *head)

static slist_node * slist_next_node(slist_head *head, slist_node *node)

static void slist_insert_after(slist_node *after, slist_node *node)

static void slist_push_head(slist_head *head, slist_node *node)

#define slist_check(head)

static bool slist_has_next(const slist_head *head, const slist_node *node)

static slist_node * slist_pop_head_node(slist_head *head)

static slist_node * slist_head_node(slist_head *head)

◆ dclist_foreach

◆ dclist_foreach_modify

◆ dclist_head_element

Value:

#define StaticAssertVariableIsOfTypeMacro(varname, typename)

static void * dclist_head_element_off(dclist_head *head, size_t off)

Definition at line 955 of file ilist.h.

◆ dclist_reverse_foreach

◆ DCLIST_STATIC_INIT

◆ dclist_tail_element

Value:

static void * dclist_tail_element_off(dclist_head *head, size_t off)

Definition at line 964 of file ilist.h.

◆ dlist_check

◆ dlist_container

◆ dlist_foreach

Value:

(iter).end = &(lhead)->head, \

(iter).cur = (iter).end->next ? (iter).end->next : (iter).end; \

(iter).cur != (iter).end; \

(iter).cur = (iter).cur->next)

Definition at line 623 of file ilist.h.

627 : (iter).end; \

628 (iter).cur != (iter).end; \

629 (iter).cur = (iter).cur->next)

◆ dlist_foreach_modify

Value:

(iter).end = &(lhead)->head, \

(iter).cur = (iter).end->next ? (iter).end->next : (iter).end, \

(iter).cur != (iter).end; \

Definition at line 640 of file ilist.h.

644 : (iter).end, \

645 (iter).next = (iter).cur->next; \

646 (iter).cur != (iter).end; \

647 (iter).cur = (iter).next, (iter).next = (iter).cur->next)

◆ dlist_head_element

Value:

static void * dlist_head_element_off(dlist_head *head, size_t off)

Definition at line 603 of file ilist.h.

◆ dlist_member_check

| #define dlist_member_check | ( | | head, | | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | | ----- | | | node | | | | | ) | ((void) (head)) | | |