/usr/include/GTGList.h is in libgtg-dev 0.2-2+dfsg-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | #ifndef GTG_LIST_H
#define GTG_LIST_H
struct gtg_list {
struct gtg_list *prev;
struct gtg_list *next;
};
typedef struct gtg_list* gtg_list_t;
/**
* \fn GTG_LIST_INIT(ptr)
* \brief initialize a list.
* \param ptr pointer to the list (gtg_list_t).
*/
#define GTG_LIST_INIT(ptr) \
do { \
(ptr)->prev = (ptr); \
(ptr)->next = (ptr); \
} while(0)
/**
* \fn GTG_LIST(name)
* \brief declare and initialize a list.
* \param name Name of the variable
*/
#define GTG_LIST(name) \
struct gtg_list name; \
GTG_LIST_INIT(&name)
/**
* \fn gtg_list_entry(ptr, type, member)
* \brief get the structure corresponding to a list entry
* \param ptr pointer to the list entry (gtg_list_t)
* \param type the type of the struct this is embedded in.
* \param member the name of the struct gtg_list member within the struct.
*/
#define gtg_list_entry(ptr, type, member) \
((type *)((char *)(ptr) - (char *)(&((type *)0)->member)))
/*
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __gtg_list_add(gtg_list_t lnew,
gtg_list_t prev,
gtg_list_t next)
{
next->prev = lnew;
lnew->next = next;
lnew->prev = prev;
prev->next = lnew;
}
/**
* \fn void gtg_list_add(gtg_list_t lnew, gtg_list_t head)
* \brief Insert a new entry after the specified head.
* \param lnew new entry to be added
* \param head list head to add it after
*/
static inline void gtg_list_add(gtg_list_t lnew, gtg_list_t head)
{
__gtg_list_add(lnew, head, head->next);
}
/**
* \fn void gtg_list_add_tail(gtg_list_t lnew, gtg_list_t head)
* \brief Insert a new entry before the specified head (ie. at the tail of the list).
* \param lnew new entry to be added
* \param head list head to add it after
*/
static inline void gtg_list_add_tail(gtg_list_t lnew, gtg_list_t head)
{
__gtg_list_add(lnew, head->prev, head);
}
/**
* Delete a list entry by making the prev/next entries
* point to each other.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __gtg_list_del(gtg_list_t prev, gtg_list_t next)
{
next->prev = prev;
prev->next = next;
}
/**
* \fn void gtg_list_del(gtg_list_t entry)
* \brief delete an entry from its list and reinitialize it.
* \param entry the element to delete from the list.
*/
static inline void gtg_list_del(gtg_list_t entry)
{
__gtg_list_del(entry->prev, entry->next);
GTG_LIST_INIT(entry);
}
/**
* \fn gtg_list_for_each(gtg_list_t pos, gtg_list_t head)
* \brief iterate over a list
* \param pos the gtg_list_t to use as a loop counter.
* \param head the head for the list.
*/
#define gtg_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
* \fn gtg_list_for_each_reverse(gtg_list_t pos, gtg_list_t head)
* \brief iterate over a list backwards
* \param pos the gtg_list_t to use as a loop counter.
* \param head the head for the list.
*/
#define gtg_list_for_each_reverse(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/**
* \fn gtg_list_for_each_safe(gtg_list_t pos, gtg_list_t n, gtg_list_t head)
* \brief iterate over a list safe against removal of list entry
* \param pos the gtg_list_t to use as a loop counter.
* \param n another gtg_list_t to use as temporary storage
* \param head the head for the list.
*/
#define gtg_list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
* gtg_list_for_each_entry(pos, head, member)
* \brief iterate over list of given type
* \param pos the type * to use as a loop counter.
* \param head the head for the list.
* \param member the name of the struct gtg_list member within the struct.
*/
#define gtg_list_for_each_entry(pos, head, member) \
for (pos = gtg_list_entry((head)->next, typeof(*pos), member); \
&pos->member != (head); \
pos = gtg_list_entry(pos->member.next, typeof(*pos), member))
/**
* gtg_list_for_each_entry_safe(pos, n, head, member)
* \brief iterate over list of given type safe against removal of list entry
* \param pos the type * to use as a loop counter.
* \param n another type * to use as temporary storage
* \param head the head for the list.
* \param member the name of the struct gtg_list member within the struct.
*/
#define gtg_list_for_each_entry_safe(pos, n, head, member) \
for (pos = gtg_list_entry((head)->next, typeof(*pos), member), \
n = gtg_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
pos = n, n = gtg_list_entry(n->member.next, typeof(*n), member))
static inline int gtg_list_size(gtg_list_t l)
{
int res = 0;
gtg_list_t ptr = NULL;
gtg_list_for_each(ptr, l)
res++;
return res;
}
#endif /* GTG_LIST_H */
|