Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * pg_list.h
4 : : * interface for PostgreSQL generic linked list package
5 : : *
6 : : * This package implements singly-linked homogeneous lists.
7 : : *
8 : : * It is important to have constant-time length, append, and prepend
9 : : * operations. To achieve this, we deal with two distinct data
10 : : * structures:
11 : : *
12 : : * 1. A set of "list cells": each cell contains a data field and
13 : : * a link to the next cell in the list or NULL.
14 : : * 2. A single structure containing metadata about the list: the
15 : : * type of the list, pointers to the head and tail cells, and
16 : : * the length of the list.
17 : : *
18 : : * We support three types of lists:
19 : : *
20 : : * T_List: lists of pointers
21 : : * (in practice usually pointers to Nodes, but not always;
22 : : * declared as "void *" to minimize casting annoyances)
23 : : * T_IntList: lists of integers
24 : : * T_OidList: lists of Oids
25 : : *
26 : : * (At the moment, ints and Oids are the same size, but they may not
27 : : * always be so; try to be careful to maintain the distinction.)
28 : : *
29 : : *
30 : : * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
31 : : * Portions Copyright (c) 1994, Regents of the University of California
32 : : *
33 : : * src/include/nodes/pg_list.h
34 : : *
35 : : *-------------------------------------------------------------------------
36 : : */
37 : : #ifndef PG_LIST_H
38 : : #define PG_LIST_H
39 : :
40 : : #include "nodes/nodes.h"
41 : :
42 : :
43 : : typedef struct ListCell ListCell;
44 : :
45 : : typedef struct List
46 : : {
47 : : NodeTag type; /* T_List, T_IntList, or T_OidList */
48 : : int length;
49 : : ListCell *head;
50 : : ListCell *tail;
51 : : } List;
52 : :
53 : : struct ListCell
54 : : {
55 : : union
56 : : {
57 : : void *ptr_value;
58 : : int int_value;
59 : : Oid oid_value;
60 : : } data;
61 : : ListCell *next;
62 : : };
63 : :
64 : : /*
65 : : * The *only* valid representation of an empty list is NIL; in other
66 : : * words, a non-NIL list is guaranteed to have length >= 1 and
67 : : * head/tail != NULL
68 : : */
69 : : #define NIL ((List *) NULL)
70 : :
71 : : /*
72 : : * These routines are used frequently. However, we can't implement
73 : : * them as macros, since we want to avoid double-evaluation of macro
74 : : * arguments. Therefore, we implement them using static inline functions
75 : : * if supported by the compiler, or as regular functions otherwise.
76 : : * See STATIC_IF_INLINE in c.h.
77 : : */
78 : : #ifndef PG_USE_INLINE
79 : : extern ListCell *list_head(const List *l);
80 : : extern ListCell *list_tail(List *l);
81 : : extern int list_length(const List *l);
82 : : #endif /* PG_USE_INLINE */
83 : : #if defined(PG_USE_INLINE) || defined(PG_LIST_INCLUDE_DEFINITIONS)
84 : : STATIC_IF_INLINE ListCell *
85 : : list_head(const List *l)
86 : : {
87 [ + + ][ + + ]: 412 : return l ? l->head : NULL;
[ + + ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ + + ]
88 : : }
89 : :
90 : : STATIC_IF_INLINE ListCell *
91 : : list_tail(List *l)
92 : : {
93 : : return l ? l->tail : NULL;
94 : : }
95 : :
96 : : STATIC_IF_INLINE int
97 : : list_length(const List *l)
98 : : {
99 : : return l ? l->length : 0;
100 : : }
101 : : #endif /*-- PG_USE_INLINE || PG_LIST_INCLUDE_DEFINITIONS */
102 : :
103 : : /*
104 : : * NB: There is an unfortunate legacy from a previous incarnation of
105 : : * the List API: the macro lfirst() was used to mean "the data in this
106 : : * cons cell". To avoid changing every usage of lfirst(), that meaning
107 : : * has been kept. As a result, lfirst() takes a ListCell and returns
108 : : * the data it contains; to get the data in the first cell of a
109 : : * List, use linitial(). Worse, lsecond() is more closely related to
110 : : * linitial() than lfirst(): given a List, lsecond() returns the data
111 : : * in the second cons cell.
112 : : */
113 : :
114 : : #define lnext(lc) ((lc)->next)
115 : : #define lfirst(lc) ((lc)->data.ptr_value)
116 : : #define lfirst_int(lc) ((lc)->data.int_value)
117 : : #define lfirst_oid(lc) ((lc)->data.oid_value)
118 : :
119 : : #define linitial(l) lfirst(list_head(l))
120 : : #define linitial_int(l) lfirst_int(list_head(l))
121 : : #define linitial_oid(l) lfirst_oid(list_head(l))
122 : :
123 : : #define lsecond(l) lfirst(lnext(list_head(l)))
124 : : #define lsecond_int(l) lfirst_int(lnext(list_head(l)))
125 : : #define lsecond_oid(l) lfirst_oid(lnext(list_head(l)))
126 : :
127 : : #define lthird(l) lfirst(lnext(lnext(list_head(l))))
128 : : #define lthird_int(l) lfirst_int(lnext(lnext(list_head(l))))
129 : : #define lthird_oid(l) lfirst_oid(lnext(lnext(list_head(l))))
130 : :
131 : : #define lfourth(l) lfirst(lnext(lnext(lnext(list_head(l)))))
132 : : #define lfourth_int(l) lfirst_int(lnext(lnext(lnext(list_head(l)))))
133 : : #define lfourth_oid(l) lfirst_oid(lnext(lnext(lnext(list_head(l)))))
134 : :
135 : : #define llast(l) lfirst(list_tail(l))
136 : : #define llast_int(l) lfirst_int(list_tail(l))
137 : : #define llast_oid(l) lfirst_oid(list_tail(l))
138 : :
139 : : /*
140 : : * Convenience macros for building fixed-length lists
141 : : */
142 : : #define list_make1(x1) lcons(x1, NIL)
143 : : #define list_make2(x1,x2) lcons(x1, list_make1(x2))
144 : : #define list_make3(x1,x2,x3) lcons(x1, list_make2(x2, x3))
145 : : #define list_make4(x1,x2,x3,x4) lcons(x1, list_make3(x2, x3, x4))
146 : :
147 : : #define list_make1_int(x1) lcons_int(x1, NIL)
148 : : #define list_make2_int(x1,x2) lcons_int(x1, list_make1_int(x2))
149 : : #define list_make3_int(x1,x2,x3) lcons_int(x1, list_make2_int(x2, x3))
150 : : #define list_make4_int(x1,x2,x3,x4) lcons_int(x1, list_make3_int(x2, x3, x4))
151 : :
152 : : #define list_make1_oid(x1) lcons_oid(x1, NIL)
153 : : #define list_make2_oid(x1,x2) lcons_oid(x1, list_make1_oid(x2))
154 : : #define list_make3_oid(x1,x2,x3) lcons_oid(x1, list_make2_oid(x2, x3))
155 : : #define list_make4_oid(x1,x2,x3,x4) lcons_oid(x1, list_make3_oid(x2, x3, x4))
156 : :
157 : : /*
158 : : * foreach -
159 : : * a convenience macro which loops through the list
160 : : */
161 : : #define foreach(cell, l) \
162 : : for ((cell) = list_head(l); (cell) != NULL; (cell) = lnext(cell))
163 : :
164 : : /*
165 : : * for_each_cell -
166 : : * a convenience macro which loops through a list starting from a
167 : : * specified cell
168 : : */
169 : : #define for_each_cell(cell, initcell) \
170 : : for ((cell) = (initcell); (cell) != NULL; (cell) = lnext(cell))
171 : :
172 : : /*
173 : : * forboth -
174 : : * a convenience macro for advancing through two linked lists
175 : : * simultaneously. This macro loops through both lists at the same
176 : : * time, stopping when either list runs out of elements. Depending
177 : : * on the requirements of the call site, it may also be wise to
178 : : * assert that the lengths of the two lists are equal.
179 : : */
180 : : #define forboth(cell1, list1, cell2, list2) \
181 : : for ((cell1) = list_head(list1), (cell2) = list_head(list2); \
182 : : (cell1) != NULL && (cell2) != NULL; \
183 : : (cell1) = lnext(cell1), (cell2) = lnext(cell2))
184 : :
185 : : /*
186 : : * forthree -
187 : : * the same for three lists
188 : : */
189 : : #define forthree(cell1, list1, cell2, list2, cell3, list3) \
190 : : for ((cell1) = list_head(list1), (cell2) = list_head(list2), (cell3) = list_head(list3); \
191 : : (cell1) != NULL && (cell2) != NULL && (cell3) != NULL; \
192 : : (cell1) = lnext(cell1), (cell2) = lnext(cell2), (cell3) = lnext(cell3))
193 : :
194 : : extern List *lappend(List *list, void *datum);
195 : : extern List *lappend_int(List *list, int datum);
196 : : extern List *lappend_oid(List *list, Oid datum);
197 : :
198 : : extern ListCell *lappend_cell(List *list, ListCell *prev, void *datum);
199 : : extern ListCell *lappend_cell_int(List *list, ListCell *prev, int datum);
200 : : extern ListCell *lappend_cell_oid(List *list, ListCell *prev, Oid datum);
201 : :
202 : : extern List *lcons(void *datum, List *list);
203 : : extern List *lcons_int(int datum, List *list);
204 : : extern List *lcons_oid(Oid datum, List *list);
205 : :
206 : : extern List *list_concat(List *list1, List *list2);
207 : : extern List *list_truncate(List *list, int new_size);
208 : :
209 : : extern void *list_nth(const List *list, int n);
210 : : extern int list_nth_int(const List *list, int n);
211 : : extern Oid list_nth_oid(const List *list, int n);
212 : :
213 : : extern bool list_member(const List *list, const void *datum);
214 : : extern bool list_member_ptr(const List *list, const void *datum);
215 : : extern bool list_member_int(const List *list, int datum);
216 : : extern bool list_member_oid(const List *list, Oid datum);
217 : :
218 : : extern List *list_delete(List *list, void *datum);
219 : : extern List *list_delete_ptr(List *list, void *datum);
220 : : extern List *list_delete_int(List *list, int datum);
221 : : extern List *list_delete_oid(List *list, Oid datum);
222 : : extern List *list_delete_first(List *list);
223 : : extern List *list_delete_cell(List *list, ListCell *cell, ListCell *prev);
224 : :
225 : : extern List *list_union(const List *list1, const List *list2);
226 : : extern List *list_union_ptr(const List *list1, const List *list2);
227 : : extern List *list_union_int(const List *list1, const List *list2);
228 : : extern List *list_union_oid(const List *list1, const List *list2);
229 : :
230 : : extern List *list_intersection(const List *list1, const List *list2);
231 : :
232 : : /* currently, there's no need for list_intersection_int etc */
233 : :
234 : : extern List *list_difference(const List *list1, const List *list2);
235 : : extern List *list_difference_ptr(const List *list1, const List *list2);
236 : : extern List *list_difference_int(const List *list1, const List *list2);
237 : : extern List *list_difference_oid(const List *list1, const List *list2);
238 : :
239 : : extern List *list_append_unique(List *list, void *datum);
240 : : extern List *list_append_unique_ptr(List *list, void *datum);
241 : : extern List *list_append_unique_int(List *list, int datum);
242 : : extern List *list_append_unique_oid(List *list, Oid datum);
243 : :
244 : : extern List *list_concat_unique(List *list1, List *list2);
245 : : extern List *list_concat_unique_ptr(List *list1, List *list2);
246 : : extern List *list_concat_unique_int(List *list1, List *list2);
247 : : extern List *list_concat_unique_oid(List *list1, List *list2);
248 : :
249 : : extern void list_free(List *list);
250 : : extern void list_free_deep(List *list);
251 : :
252 : : extern List *list_copy(const List *list);
253 : : extern List *list_copy_tail(const List *list, int nskip);
254 : :
255 : : /*
256 : : * To ease migration to the new list API, a set of compatibility
257 : : * macros are provided that reduce the impact of the list API changes
258 : : * as far as possible. Until client code has been rewritten to use the
259 : : * new list API, the ENABLE_LIST_COMPAT symbol can be defined before
260 : : * including pg_list.h
261 : : */
262 : : #ifdef ENABLE_LIST_COMPAT
263 : :
264 : : #define lfirsti(lc) lfirst_int(lc)
265 : : #define lfirsto(lc) lfirst_oid(lc)
266 : :
267 : : #define makeList1(x1) list_make1(x1)
268 : : #define makeList2(x1, x2) list_make2(x1, x2)
269 : : #define makeList3(x1, x2, x3) list_make3(x1, x2, x3)
270 : : #define makeList4(x1, x2, x3, x4) list_make4(x1, x2, x3, x4)
271 : :
272 : : #define makeListi1(x1) list_make1_int(x1)
273 : : #define makeListi2(x1, x2) list_make2_int(x1, x2)
274 : :
275 : : #define makeListo1(x1) list_make1_oid(x1)
276 : : #define makeListo2(x1, x2) list_make2_oid(x1, x2)
277 : :
278 : : #define lconsi(datum, list) lcons_int(datum, list)
279 : : #define lconso(datum, list) lcons_oid(datum, list)
280 : :
281 : : #define lappendi(list, datum) lappend_int(list, datum)
282 : : #define lappendo(list, datum) lappend_oid(list, datum)
283 : :
284 : : #define nconc(l1, l2) list_concat(l1, l2)
285 : :
286 : : #define nth(n, list) list_nth(list, n)
287 : :
288 : : #define member(datum, list) list_member(list, datum)
289 : : #define ptrMember(datum, list) list_member_ptr(list, datum)
290 : : #define intMember(datum, list) list_member_int(list, datum)
291 : : #define oidMember(datum, list) list_member_oid(list, datum)
292 : :
293 : : /*
294 : : * Note that the old lremove() determined equality via pointer
295 : : * comparison, whereas the new list_delete() uses equal(); in order to
296 : : * keep the same behavior, we therefore need to map lremove() calls to
297 : : * list_delete_ptr() rather than list_delete()
298 : : */
299 : : #define lremove(elem, list) list_delete_ptr(list, elem)
300 : : #define LispRemove(elem, list) list_delete(list, elem)
301 : : #define lremovei(elem, list) list_delete_int(list, elem)
302 : : #define lremoveo(elem, list) list_delete_oid(list, elem)
303 : :
304 : : #define ltruncate(n, list) list_truncate(list, n)
305 : :
306 : : #define set_union(l1, l2) list_union(l1, l2)
307 : : #define set_uniono(l1, l2) list_union_oid(l1, l2)
308 : : #define set_ptrUnion(l1, l2) list_union_ptr(l1, l2)
309 : :
310 : : #define set_difference(l1, l2) list_difference(l1, l2)
311 : : #define set_differenceo(l1, l2) list_difference_oid(l1, l2)
312 : : #define set_ptrDifference(l1, l2) list_difference_ptr(l1, l2)
313 : :
314 : : #define equali(l1, l2) equal(l1, l2)
315 : : #define equalo(l1, l2) equal(l1, l2)
316 : :
317 : : #define freeList(list) list_free(list)
318 : :
319 : : #define listCopy(list) list_copy(list)
320 : :
321 : : extern int length(List *list);
322 : : #endif /* ENABLE_LIST_COMPAT */
323 : :
324 : : #endif /* PG_LIST_H */
|