debase-ruby_core_source 0.10.6 → 0.10.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (57) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +5 -0
  3. data/lib/debase/ruby_core_source.rb +2 -1
  4. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/addr2line.h +21 -0
  5. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ccan/build_assert/build_assert.h +40 -0
  6. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ccan/check_type/check_type.h +63 -0
  7. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ccan/container_of/container_of.h +142 -0
  8. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ccan/list/list.h +788 -0
  9. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ccan/str/str.h +16 -0
  10. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/constant.h +54 -0
  11. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/debug_counter.h +378 -0
  12. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/dln.h +51 -0
  13. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/encindex.h +69 -0
  14. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/eval_intern.h +314 -0
  15. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/gc.h +129 -0
  16. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/hrtime.h +168 -0
  17. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/id.h +292 -0
  18. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/id_table.h +34 -0
  19. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/insns.inc +249 -0
  20. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/insns_info.inc +9614 -0
  21. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/internal.h +2682 -0
  22. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/iseq.h +312 -0
  23. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/known_errors.inc +791 -0
  24. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/method.h +232 -0
  25. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/mjit.h +179 -0
  26. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/mjit_compile.inc +7883 -0
  27. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/node.h +483 -0
  28. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/node_name.inc +210 -0
  29. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/opt_sc.inc +109 -0
  30. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/optinsn.inc +128 -0
  31. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/optunifs.inc +43 -0
  32. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/parse.h +210 -0
  33. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/probes_helper.h +42 -0
  34. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/regenc.h +254 -0
  35. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/regint.h +938 -0
  36. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/regparse.h +370 -0
  37. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/revision.h +2 -0
  38. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ruby_assert.h +15 -0
  39. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/ruby_atomic.h +244 -0
  40. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/siphash.h +48 -0
  41. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/symbol.h +119 -0
  42. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/thread_pthread.h +75 -0
  43. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/thread_win32.h +36 -0
  44. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/timev.h +56 -0
  45. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/transcode_data.h +139 -0
  46. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/transient_heap.h +62 -0
  47. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/version.h +77 -0
  48. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm.inc +5269 -0
  49. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_call_iseq_optimized.inc +237 -0
  50. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_core.h +1955 -0
  51. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_debug.h +34 -0
  52. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_exec.h +193 -0
  53. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_insnhelper.h +255 -0
  54. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vm_opts.h +70 -0
  55. data/lib/debase/ruby_core_source/ruby-2.7.0-preview2/vmtc.inc +243 -0
  56. data/lib/debase/ruby_core_source/version.rb +1 -1
  57. metadata +55 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: c39bb929d421b3c70c8cd6128150796a99dee2eb1f63c300c347c07125a083fc
4
- data.tar.gz: de579a2fb072cc02045870a3b248128976b3ac623f4af9ecb30891c5a46ea915
3
+ metadata.gz: a297c7f2cc26dfbedf9c9528663829e35e922593a1a7cd59bec49b9c3bd4aebd
4
+ data.tar.gz: b2bd37cf3fab5655f45bf5635c979729ca21c8517aee8f7a85ff40600f647505
5
5
  SHA512:
6
- metadata.gz: b776af4e80e7a7805494801da5b75adedf11b967f1c5a5da901b4b3a53039fe1fb666ba9a9b5b21d0f62b9beb3a99f71d3d91bb1dcbaa4a3095cd4a1451cdbb4
7
- data.tar.gz: b089a520ad8d77079552738bce018a8890fc5ac243d535d8d3d51bbbe70c539941ff0d370a02115a532f92df56a807bee8aebb4fb9c24d69b85d086f31ad0df5
6
+ metadata.gz: 93c489b3c93c2522e86911df9c810bde834d5824897364903d75af2e09e3962647a25fa5b2954f882e4f547473eeefd37a33e3d73dc7ab82ab5ddcb5cb357d3f
7
+ data.tar.gz: c4f6e442ade3f8eb2fc60091c0aca3c4a7d4c37600b1f0c20a8aef63b0643c49abff4db642cb503c11e1c32e48812e87ddfa27492b1d1397a9eebe9d04a4c7cb
data/CHANGELOG.md CHANGED
@@ -1,3 +1,8 @@
1
+ ## [0.10.7](https://github.com/os97673/debase-ruby_core_source/compare/v0.10.6...v0.10.7)
2
+
3
+ * ruby 2.7.0-preview2 added (contributed by [ViugiNick](https://github.com/ViugiNick))
4
+ * ruby location search fixed to work with preview rubies (contributed by [ViugiNick](https://github.com/ViugiNick))
5
+
1
6
  ## [0.10.6](https://github.com/os97673/debase-ruby_core_source/compare/v0.10.5...v0.10.6)
2
7
 
3
8
  * ruby 2.6.5 added (contributed by [niw](https://github.com/niw))
@@ -8,6 +8,7 @@ module Debase
8
8
  # Revision can be found at `revision.h` of ruby sources.
9
9
  # Format of this hash:
10
10
  # <RUBY_REVISION> => '<sources directory name>', e.g. `61243 => 'ruby-2.5.0-rc1'`
11
+ '02aadf1032d71a3f81653a955f2635c8853b0aca' => 'ruby-2.7.0-preview2',
11
12
  }
12
13
 
13
14
  def self.create_makefile_with_core(hdrs, name)
@@ -68,7 +69,7 @@ module Debase
68
69
  end
69
70
 
70
71
  def self.ruby_source_dir_version(dir)
71
- match = /ruby-([0-9\.]+)-((p|rc)[0-9]+)\z/.match(dir)
72
+ match = /ruby-([0-9\.]+)-((p|rc|preview)[0-9]+)\z/.match(dir)
72
73
  Gem::Version.new("#{match[1]}.#{match[2]}")
73
74
  end
74
75
 
@@ -0,0 +1,21 @@
1
+ /**********************************************************************
2
+
3
+ addr2line.h -
4
+
5
+ $Author$
6
+
7
+ Copyright (C) 2010 Shinichiro Hamaji
8
+
9
+ **********************************************************************/
10
+
11
+ #ifndef RUBY_ADDR2LINE_H
12
+ #define RUBY_ADDR2LINE_H
13
+
14
+ #if (defined(USE_ELF) || defined(HAVE_MACH_O_LOADER_H))
15
+
16
+ void
17
+ rb_dump_backtrace_with_lines(int num_traces, void **traces);
18
+
19
+ #endif /* USE_ELF */
20
+
21
+ #endif /* RUBY_ADDR2LINE_H */
@@ -0,0 +1,40 @@
1
+ /* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2
+ #ifndef CCAN_BUILD_ASSERT_H
3
+ #define CCAN_BUILD_ASSERT_H
4
+
5
+ /**
6
+ * BUILD_ASSERT - assert a build-time dependency.
7
+ * @cond: the compile-time condition which must be true.
8
+ *
9
+ * Your compile will fail if the condition isn't true, or can't be evaluated
10
+ * by the compiler. This can only be used within a function.
11
+ *
12
+ * Example:
13
+ * #include <stddef.h>
14
+ * ...
15
+ * static char *foo_to_char(struct foo *foo)
16
+ * {
17
+ * // This code needs string to be at start of foo.
18
+ * BUILD_ASSERT(offsetof(struct foo, string) == 0);
19
+ * return (char *)foo;
20
+ * }
21
+ */
22
+ #define BUILD_ASSERT(cond) \
23
+ do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
24
+
25
+ /**
26
+ * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
27
+ * @cond: the compile-time condition which must be true.
28
+ *
29
+ * Your compile will fail if the condition isn't true, or can't be evaluated
30
+ * by the compiler. This can be used in an expression: its value is "0".
31
+ *
32
+ * Example:
33
+ * #define foo_to_char(foo) \
34
+ * ((char *)(foo) \
35
+ * + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
36
+ */
37
+ #define BUILD_ASSERT_OR_ZERO(cond) \
38
+ (sizeof(char [1 - 2*!(cond)]) - 1)
39
+
40
+ #endif /* CCAN_BUILD_ASSERT_H */
@@ -0,0 +1,63 @@
1
+ /* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2
+ #ifndef CCAN_CHECK_TYPE_H
3
+ #define CCAN_CHECK_TYPE_H
4
+
5
+ /**
6
+ * check_type - issue a warning or build failure if type is not correct.
7
+ * @expr: the expression whose type we should check (not evaluated).
8
+ * @type: the exact type we expect the expression to be.
9
+ *
10
+ * This macro is usually used within other macros to try to ensure that a macro
11
+ * argument is of the expected type. No type promotion of the expression is
12
+ * done: an unsigned int is not the same as an int!
13
+ *
14
+ * check_type() always evaluates to 0.
15
+ *
16
+ * If your compiler does not support typeof, then the best we can do is fail
17
+ * to compile if the sizes of the types are unequal (a less complete check).
18
+ *
19
+ * Example:
20
+ * // They should always pass a 64-bit value to _set_some_value!
21
+ * #define set_some_value(expr) \
22
+ * _set_some_value((check_type((expr), uint64_t), (expr)))
23
+ */
24
+
25
+ /**
26
+ * check_types_match - issue a warning or build failure if types are not same.
27
+ * @expr1: the first expression (not evaluated).
28
+ * @expr2: the second expression (not evaluated).
29
+ *
30
+ * This macro is usually used within other macros to try to ensure that
31
+ * arguments are of identical types. No type promotion of the expressions is
32
+ * done: an unsigned int is not the same as an int!
33
+ *
34
+ * check_types_match() always evaluates to 0.
35
+ *
36
+ * If your compiler does not support typeof, then the best we can do is fail
37
+ * to compile if the sizes of the types are unequal (a less complete check).
38
+ *
39
+ * Example:
40
+ * // Do subtraction to get to enclosing type, but make sure that
41
+ * // pointer is of correct type for that member.
42
+ * #define container_of(mbr_ptr, encl_type, mbr) \
43
+ * (check_types_match((mbr_ptr), &((encl_type *)0)->mbr), \
44
+ * ((encl_type *) \
45
+ * ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
46
+ */
47
+ #if HAVE_TYPEOF
48
+ #define check_type(expr, type) \
49
+ ((typeof(expr) *)0 != (type *)0)
50
+
51
+ #define check_types_match(expr1, expr2) \
52
+ ((typeof(expr1) *)0 != (typeof(expr2) *)0)
53
+ #else
54
+ #include "ccan/build_assert/build_assert.h"
55
+ /* Without typeof, we can only test the sizes. */
56
+ #define check_type(expr, type) \
57
+ BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
58
+
59
+ #define check_types_match(expr1, expr2) \
60
+ BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
61
+ #endif /* HAVE_TYPEOF */
62
+
63
+ #endif /* CCAN_CHECK_TYPE_H */
@@ -0,0 +1,142 @@
1
+ /* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2
+ #ifndef CCAN_CONTAINER_OF_H
3
+ #define CCAN_CONTAINER_OF_H
4
+ #include "ccan/check_type/check_type.h"
5
+
6
+ /**
7
+ * container_of - get pointer to enclosing structure
8
+ * @member_ptr: pointer to the structure member
9
+ * @containing_type: the type this member is within
10
+ * @member: the name of this member within the structure.
11
+ *
12
+ * Given a pointer to a member of a structure, this macro does pointer
13
+ * subtraction to return the pointer to the enclosing type.
14
+ *
15
+ * Example:
16
+ * struct foo {
17
+ * int fielda, fieldb;
18
+ * // ...
19
+ * };
20
+ * struct info {
21
+ * int some_other_field;
22
+ * struct foo my_foo;
23
+ * };
24
+ *
25
+ * static struct info *foo_to_info(struct foo *foo)
26
+ * {
27
+ * return container_of(foo, struct info, my_foo);
28
+ * }
29
+ */
30
+ #define container_of(member_ptr, containing_type, member) \
31
+ ((containing_type *) \
32
+ ((char *)(member_ptr) \
33
+ - container_off(containing_type, member)) \
34
+ + check_types_match(*(member_ptr), ((containing_type *)0)->member))
35
+
36
+
37
+ /**
38
+ * container_of_or_null - get pointer to enclosing structure, or NULL
39
+ * @member_ptr: pointer to the structure member
40
+ * @containing_type: the type this member is within
41
+ * @member: the name of this member within the structure.
42
+ *
43
+ * Given a pointer to a member of a structure, this macro does pointer
44
+ * subtraction to return the pointer to the enclosing type, unless it
45
+ * is given NULL, in which case it also returns NULL.
46
+ *
47
+ * Example:
48
+ * struct foo {
49
+ * int fielda, fieldb;
50
+ * // ...
51
+ * };
52
+ * struct info {
53
+ * int some_other_field;
54
+ * struct foo my_foo;
55
+ * };
56
+ *
57
+ * static struct info *foo_to_info_allowing_null(struct foo *foo)
58
+ * {
59
+ * return container_of_or_null(foo, struct info, my_foo);
60
+ * }
61
+ */
62
+ static inline char *container_of_or_null_(void *member_ptr, size_t offset)
63
+ {
64
+ return member_ptr ? (char *)member_ptr - offset : NULL;
65
+ }
66
+ #define container_of_or_null(member_ptr, containing_type, member) \
67
+ ((containing_type *) \
68
+ container_of_or_null_(member_ptr, \
69
+ container_off(containing_type, member)) \
70
+ + check_types_match(*(member_ptr), ((containing_type *)0)->member))
71
+
72
+ /**
73
+ * container_off - get offset to enclosing structure
74
+ * @containing_type: the type this member is within
75
+ * @member: the name of this member within the structure.
76
+ *
77
+ * Given a pointer to a member of a structure, this macro does
78
+ * typechecking and figures out the offset to the enclosing type.
79
+ *
80
+ * Example:
81
+ * struct foo {
82
+ * int fielda, fieldb;
83
+ * // ...
84
+ * };
85
+ * struct info {
86
+ * int some_other_field;
87
+ * struct foo my_foo;
88
+ * };
89
+ *
90
+ * static struct info *foo_to_info(struct foo *foo)
91
+ * {
92
+ * size_t off = container_off(struct info, my_foo);
93
+ * return (void *)((char *)foo - off);
94
+ * }
95
+ */
96
+ #define container_off(containing_type, member) \
97
+ offsetof(containing_type, member)
98
+
99
+ /**
100
+ * container_of_var - get pointer to enclosing structure using a variable
101
+ * @member_ptr: pointer to the structure member
102
+ * @container_var: a pointer of same type as this member's container
103
+ * @member: the name of this member within the structure.
104
+ *
105
+ * Given a pointer to a member of a structure, this macro does pointer
106
+ * subtraction to return the pointer to the enclosing type.
107
+ *
108
+ * Example:
109
+ * static struct info *foo_to_i(struct foo *foo)
110
+ * {
111
+ * struct info *i = container_of_var(foo, i, my_foo);
112
+ * return i;
113
+ * }
114
+ */
115
+ #if HAVE_TYPEOF
116
+ #define container_of_var(member_ptr, container_var, member) \
117
+ container_of(member_ptr, typeof(*container_var), member)
118
+ #else
119
+ #define container_of_var(member_ptr, container_var, member) \
120
+ ((void *)((char *)(member_ptr) - \
121
+ container_off_var(container_var, member)))
122
+ #endif
123
+
124
+ /**
125
+ * container_off_var - get offset of a field in enclosing structure
126
+ * @container_var: a pointer to a container structure
127
+ * @member: the name of a member within the structure.
128
+ *
129
+ * Given (any) pointer to a structure and a its member name, this
130
+ * macro does pointer subtraction to return offset of member in a
131
+ * structure memory layout.
132
+ *
133
+ */
134
+ #if HAVE_TYPEOF
135
+ #define container_off_var(var, member) \
136
+ container_off(typeof(*var), member)
137
+ #else
138
+ #define container_off_var(var, member) \
139
+ ((const char *)&(var)->member - (const char *)(var))
140
+ #endif
141
+
142
+ #endif /* CCAN_CONTAINER_OF_H */
@@ -0,0 +1,788 @@
1
+ /* Licensed under BSD-MIT - see ccan/licenses/BSD-MIT file for details */
2
+ #ifndef CCAN_LIST_H
3
+ #define CCAN_LIST_H
4
+ #include <assert.h>
5
+ #include "ccan/str/str.h"
6
+ #include "ccan/container_of/container_of.h"
7
+ #include "ccan/check_type/check_type.h"
8
+
9
+ /**
10
+ * struct list_node - an entry in a doubly-linked list
11
+ * @next: next entry (self if empty)
12
+ * @prev: previous entry (self if empty)
13
+ *
14
+ * This is used as an entry in a linked list.
15
+ * Example:
16
+ * struct child {
17
+ * const char *name;
18
+ * // Linked list of all us children.
19
+ * struct list_node list;
20
+ * };
21
+ */
22
+ struct list_node
23
+ {
24
+ struct list_node *next, *prev;
25
+ };
26
+
27
+ /**
28
+ * struct list_head - the head of a doubly-linked list
29
+ * @h: the list_head (containing next and prev pointers)
30
+ *
31
+ * This is used as the head of a linked list.
32
+ * Example:
33
+ * struct parent {
34
+ * const char *name;
35
+ * struct list_head children;
36
+ * unsigned int num_children;
37
+ * };
38
+ */
39
+ struct list_head
40
+ {
41
+ struct list_node n;
42
+ };
43
+
44
+ #define LIST_LOC __FILE__ ":" stringify(__LINE__)
45
+ #define list_debug(h, loc) ((void)loc, h)
46
+ #define list_debug_node(n, loc) ((void)loc, n)
47
+
48
+ /**
49
+ * LIST_HEAD_INIT - initializer for an empty list_head
50
+ * @name: the name of the list.
51
+ *
52
+ * Explicit initializer for an empty list.
53
+ *
54
+ * See also:
55
+ * LIST_HEAD, list_head_init()
56
+ *
57
+ * Example:
58
+ * static struct list_head my_list = LIST_HEAD_INIT(my_list);
59
+ */
60
+ #define LIST_HEAD_INIT(name) { { &(name).n, &(name).n } }
61
+
62
+ /**
63
+ * LIST_HEAD - define and initialize an empty list_head
64
+ * @name: the name of the list.
65
+ *
66
+ * The LIST_HEAD macro defines a list_head and initializes it to an empty
67
+ * list. It can be prepended by "static" to define a static list_head.
68
+ *
69
+ * See also:
70
+ * LIST_HEAD_INIT, list_head_init()
71
+ *
72
+ * Example:
73
+ * static LIST_HEAD(my_global_list);
74
+ */
75
+ #define LIST_HEAD(name) \
76
+ struct list_head name = LIST_HEAD_INIT(name)
77
+
78
+ /**
79
+ * list_head_init - initialize a list_head
80
+ * @h: the list_head to set to the empty list
81
+ *
82
+ * Example:
83
+ * ...
84
+ * struct parent *parent = malloc(sizeof(*parent));
85
+ *
86
+ * list_head_init(&parent->children);
87
+ * parent->num_children = 0;
88
+ */
89
+ static inline void list_head_init(struct list_head *h)
90
+ {
91
+ h->n.next = h->n.prev = &h->n;
92
+ }
93
+
94
+ /**
95
+ * list_node_init - initialize a list_node
96
+ * @n: the list_node to link to itself.
97
+ *
98
+ * You don't need to use this normally! But it lets you list_del(@n)
99
+ * safely.
100
+ */
101
+ static inline void list_node_init(struct list_node *n)
102
+ {
103
+ n->next = n->prev = n;
104
+ }
105
+
106
+ /**
107
+ * list_add_after - add an entry after an existing node in a linked list
108
+ * @h: the list_head to add the node to (for debugging)
109
+ * @p: the existing list_node to add the node after
110
+ * @n: the new list_node to add to the list.
111
+ *
112
+ * The existing list_node must already be a member of the list.
113
+ * The new list_node does not need to be initialized; it will be overwritten.
114
+ *
115
+ * Example:
116
+ * struct child c1, c2, c3;
117
+ * LIST_HEAD(h);
118
+ *
119
+ * list_add_tail(&h, &c1.list);
120
+ * list_add_tail(&h, &c3.list);
121
+ * list_add_after(&h, &c1.list, &c2.list);
122
+ */
123
+ #define list_add_after(h, p, n) list_add_after_(h, p, n, LIST_LOC)
124
+ static inline void list_add_after_(struct list_head *h,
125
+ struct list_node *p,
126
+ struct list_node *n,
127
+ const char *abortstr)
128
+ {
129
+ n->next = p->next;
130
+ n->prev = p;
131
+ p->next->prev = n;
132
+ p->next = n;
133
+ (void)list_debug(h, abortstr);
134
+ }
135
+
136
+ /**
137
+ * list_add - add an entry at the start of a linked list.
138
+ * @h: the list_head to add the node to
139
+ * @n: the list_node to add to the list.
140
+ *
141
+ * The list_node does not need to be initialized; it will be overwritten.
142
+ * Example:
143
+ * struct child *child = malloc(sizeof(*child));
144
+ *
145
+ * child->name = "marvin";
146
+ * list_add(&parent->children, &child->list);
147
+ * parent->num_children++;
148
+ */
149
+ #define list_add(h, n) list_add_(h, n, LIST_LOC)
150
+ static inline void list_add_(struct list_head *h,
151
+ struct list_node *n,
152
+ const char *abortstr)
153
+ {
154
+ list_add_after_(h, &h->n, n, abortstr);
155
+ }
156
+
157
+ /**
158
+ * list_add_before - add an entry before an existing node in a linked list
159
+ * @h: the list_head to add the node to (for debugging)
160
+ * @p: the existing list_node to add the node before
161
+ * @n: the new list_node to add to the list.
162
+ *
163
+ * The existing list_node must already be a member of the list.
164
+ * The new list_node does not need to be initialized; it will be overwritten.
165
+ *
166
+ * Example:
167
+ * list_head_init(&h);
168
+ * list_add_tail(&h, &c1.list);
169
+ * list_add_tail(&h, &c3.list);
170
+ * list_add_before(&h, &c3.list, &c2.list);
171
+ */
172
+ #define list_add_before(h, p, n) list_add_before_(h, p, n, LIST_LOC)
173
+ static inline void list_add_before_(struct list_head *h,
174
+ struct list_node *p,
175
+ struct list_node *n,
176
+ const char *abortstr)
177
+ {
178
+ n->next = p;
179
+ n->prev = p->prev;
180
+ p->prev->next = n;
181
+ p->prev = n;
182
+ (void)list_debug(h, abortstr);
183
+ }
184
+
185
+ /**
186
+ * list_add_tail - add an entry at the end of a linked list.
187
+ * @h: the list_head to add the node to
188
+ * @n: the list_node to add to the list.
189
+ *
190
+ * The list_node does not need to be initialized; it will be overwritten.
191
+ * Example:
192
+ * list_add_tail(&parent->children, &child->list);
193
+ * parent->num_children++;
194
+ */
195
+ #define list_add_tail(h, n) list_add_tail_(h, n, LIST_LOC)
196
+ static inline void list_add_tail_(struct list_head *h,
197
+ struct list_node *n,
198
+ const char *abortstr)
199
+ {
200
+ list_add_before_(h, &h->n, n, abortstr);
201
+ }
202
+
203
+ /**
204
+ * list_empty - is a list empty?
205
+ * @h: the list_head
206
+ *
207
+ * If the list is empty, returns true.
208
+ *
209
+ * Example:
210
+ * assert(list_empty(&parent->children) == (parent->num_children == 0));
211
+ */
212
+ #define list_empty(h) list_empty_(h, LIST_LOC)
213
+ static inline int list_empty_(const struct list_head *h, const char* abortstr)
214
+ {
215
+ (void)list_debug(h, abortstr);
216
+ return h->n.next == &h->n;
217
+ }
218
+
219
+ /**
220
+ * list_empty_nodebug - is a list empty (and don't perform debug checks)?
221
+ * @h: the list_head
222
+ *
223
+ * If the list is empty, returns true.
224
+ * This differs from list_empty() in that if CCAN_LIST_DEBUG is set it
225
+ * will NOT perform debug checks. Only use this function if you REALLY
226
+ * know what you're doing.
227
+ *
228
+ * Example:
229
+ * assert(list_empty_nodebug(&parent->children) == (parent->num_children == 0));
230
+ */
231
+ #ifndef CCAN_LIST_DEBUG
232
+ #define list_empty_nodebug(h) list_empty(h)
233
+ #else
234
+ static inline int list_empty_nodebug(const struct list_head *h)
235
+ {
236
+ return h->n.next == &h->n;
237
+ }
238
+ #endif
239
+
240
+ /**
241
+ * list_empty_nocheck - is a list empty?
242
+ * @h: the list_head
243
+ *
244
+ * If the list is empty, returns true. This doesn't perform any
245
+ * debug check for list consistency, so it can be called without
246
+ * locks, racing with the list being modified. This is ok for
247
+ * checks where an incorrect result is not an issue (optimized
248
+ * bail out path for example).
249
+ */
250
+ static inline bool list_empty_nocheck(const struct list_head *h)
251
+ {
252
+ return h->n.next == &h->n;
253
+ }
254
+
255
+ /**
256
+ * list_del - delete an entry from an (unknown) linked list.
257
+ * @n: the list_node to delete from the list.
258
+ *
259
+ * Note that this leaves @n in an undefined state; it can be added to
260
+ * another list, but not deleted again.
261
+ *
262
+ * See also:
263
+ * list_del_from(), list_del_init()
264
+ *
265
+ * Example:
266
+ * list_del(&child->list);
267
+ * parent->num_children--;
268
+ */
269
+ #define list_del(n) list_del_(n, LIST_LOC)
270
+ static inline void list_del_(struct list_node *n, const char* abortstr)
271
+ {
272
+ (void)list_debug_node(n, abortstr);
273
+ n->next->prev = n->prev;
274
+ n->prev->next = n->next;
275
+ #ifdef CCAN_LIST_DEBUG
276
+ /* Catch use-after-del. */
277
+ n->next = n->prev = NULL;
278
+ #endif
279
+ }
280
+
281
+ /**
282
+ * list_del_init - delete a node, and reset it so it can be deleted again.
283
+ * @n: the list_node to be deleted.
284
+ *
285
+ * list_del(@n) or list_del_init() again after this will be safe,
286
+ * which can be useful in some cases.
287
+ *
288
+ * See also:
289
+ * list_del_from(), list_del()
290
+ *
291
+ * Example:
292
+ * list_del_init(&child->list);
293
+ * parent->num_children--;
294
+ */
295
+ #define list_del_init(n) list_del_init_(n, LIST_LOC)
296
+ static inline void list_del_init_(struct list_node *n, const char *abortstr)
297
+ {
298
+ list_del_(n, abortstr);
299
+ list_node_init(n);
300
+ }
301
+
302
+ /**
303
+ * list_del_from - delete an entry from a known linked list.
304
+ * @h: the list_head the node is in.
305
+ * @n: the list_node to delete from the list.
306
+ *
307
+ * This explicitly indicates which list a node is expected to be in,
308
+ * which is better documentation and can catch more bugs.
309
+ *
310
+ * See also: list_del()
311
+ *
312
+ * Example:
313
+ * list_del_from(&parent->children, &child->list);
314
+ * parent->num_children--;
315
+ */
316
+ static inline void list_del_from(struct list_head *h, struct list_node *n)
317
+ {
318
+ #ifdef CCAN_LIST_DEBUG
319
+ {
320
+ /* Thorough check: make sure it was in list! */
321
+ struct list_node *i;
322
+ for (i = h->n.next; i != n; i = i->next)
323
+ assert(i != &h->n);
324
+ }
325
+ #endif /* CCAN_LIST_DEBUG */
326
+
327
+ /* Quick test that catches a surprising number of bugs. */
328
+ assert(!list_empty(h));
329
+ list_del(n);
330
+ }
331
+
332
+ /**
333
+ * list_swap - swap out an entry from an (unknown) linked list for a new one.
334
+ * @o: the list_node to replace from the list.
335
+ * @n: the list_node to insert in place of the old one.
336
+ *
337
+ * Note that this leaves @o in an undefined state; it can be added to
338
+ * another list, but not deleted/swapped again.
339
+ *
340
+ * See also:
341
+ * list_del()
342
+ *
343
+ * Example:
344
+ * struct child x1, x2;
345
+ * LIST_HEAD(xh);
346
+ *
347
+ * list_add(&xh, &x1.list);
348
+ * list_swap(&x1.list, &x2.list);
349
+ */
350
+ #define list_swap(o, n) list_swap_(o, n, LIST_LOC)
351
+ static inline void list_swap_(struct list_node *o,
352
+ struct list_node *n,
353
+ const char* abortstr)
354
+ {
355
+ (void)list_debug_node(o, abortstr);
356
+ *n = *o;
357
+ n->next->prev = n;
358
+ n->prev->next = n;
359
+ #ifdef CCAN_LIST_DEBUG
360
+ /* Catch use-after-del. */
361
+ o->next = o->prev = NULL;
362
+ #endif
363
+ }
364
+
365
+ /**
366
+ * list_entry - convert a list_node back into the structure containing it.
367
+ * @n: the list_node
368
+ * @type: the type of the entry
369
+ * @member: the list_node member of the type
370
+ *
371
+ * Example:
372
+ * // First list entry is children.next; convert back to child.
373
+ * child = list_entry(parent->children.n.next, struct child, list);
374
+ *
375
+ * See Also:
376
+ * list_top(), list_for_each()
377
+ */
378
+ #define list_entry(n, type, member) container_of(n, type, member)
379
+
380
+ /**
381
+ * list_top - get the first entry in a list
382
+ * @h: the list_head
383
+ * @type: the type of the entry
384
+ * @member: the list_node member of the type
385
+ *
386
+ * If the list is empty, returns NULL.
387
+ *
388
+ * Example:
389
+ * struct child *first;
390
+ * first = list_top(&parent->children, struct child, list);
391
+ * if (!first)
392
+ * printf("Empty list!\n");
393
+ */
394
+ #define list_top(h, type, member) \
395
+ ((type *)list_top_((h), list_off_(type, member)))
396
+
397
+ static inline const void *list_top_(const struct list_head *h, size_t off)
398
+ {
399
+ if (list_empty(h))
400
+ return NULL;
401
+ return (const char *)h->n.next - off;
402
+ }
403
+
404
+ /**
405
+ * list_pop - remove the first entry in a list
406
+ * @h: the list_head
407
+ * @type: the type of the entry
408
+ * @member: the list_node member of the type
409
+ *
410
+ * If the list is empty, returns NULL.
411
+ *
412
+ * Example:
413
+ * struct child *one;
414
+ * one = list_pop(&parent->children, struct child, list);
415
+ * if (!one)
416
+ * printf("Empty list!\n");
417
+ */
418
+ #define list_pop(h, type, member) \
419
+ ((type *)list_pop_((h), list_off_(type, member)))
420
+
421
+ static inline const void *list_pop_(const struct list_head *h, size_t off)
422
+ {
423
+ struct list_node *n;
424
+
425
+ if (list_empty(h))
426
+ return NULL;
427
+ n = h->n.next;
428
+ list_del(n);
429
+ return (const char *)n - off;
430
+ }
431
+
432
+ /**
433
+ * list_tail - get the last entry in a list
434
+ * @h: the list_head
435
+ * @type: the type of the entry
436
+ * @member: the list_node member of the type
437
+ *
438
+ * If the list is empty, returns NULL.
439
+ *
440
+ * Example:
441
+ * struct child *last;
442
+ * last = list_tail(&parent->children, struct child, list);
443
+ * if (!last)
444
+ * printf("Empty list!\n");
445
+ */
446
+ #define list_tail(h, type, member) \
447
+ ((type *)list_tail_((h), list_off_(type, member)))
448
+
449
+ static inline const void *list_tail_(const struct list_head *h, size_t off)
450
+ {
451
+ if (list_empty(h))
452
+ return NULL;
453
+ return (const char *)h->n.prev - off;
454
+ }
455
+
456
+ /**
457
+ * list_for_each - iterate through a list.
458
+ * @h: the list_head (warning: evaluated multiple times!)
459
+ * @i: the structure containing the list_node
460
+ * @member: the list_node member of the structure
461
+ *
462
+ * This is a convenient wrapper to iterate @i over the entire list. It's
463
+ * a for loop, so you can break and continue as normal.
464
+ *
465
+ * Example:
466
+ * list_for_each(&parent->children, child, list)
467
+ * printf("Name: %s\n", child->name);
468
+ */
469
+ #define list_for_each(h, i, member) \
470
+ list_for_each_off(h, i, list_off_var_(i, member))
471
+
472
+ /**
473
+ * list_for_each_rev - iterate through a list backwards.
474
+ * @h: the list_head
475
+ * @i: the structure containing the list_node
476
+ * @member: the list_node member of the structure
477
+ *
478
+ * This is a convenient wrapper to iterate @i over the entire list. It's
479
+ * a for loop, so you can break and continue as normal.
480
+ *
481
+ * Example:
482
+ * list_for_each_rev(&parent->children, child, list)
483
+ * printf("Name: %s\n", child->name);
484
+ */
485
+ #define list_for_each_rev(h, i, member) \
486
+ list_for_each_rev_off(h, i, list_off_var_(i, member))
487
+
488
+ /**
489
+ * list_for_each_rev_safe - iterate through a list backwards,
490
+ * maybe during deletion
491
+ * @h: the list_head
492
+ * @i: the structure containing the list_node
493
+ * @nxt: the structure containing the list_node
494
+ * @member: the list_node member of the structure
495
+ *
496
+ * This is a convenient wrapper to iterate @i over the entire list backwards.
497
+ * It's a for loop, so you can break and continue as normal. The extra
498
+ * variable * @nxt is used to hold the next element, so you can delete @i
499
+ * from the list.
500
+ *
501
+ * Example:
502
+ * struct child *next;
503
+ * list_for_each_rev_safe(&parent->children, child, next, list) {
504
+ * printf("Name: %s\n", child->name);
505
+ * }
506
+ */
507
+ #define list_for_each_rev_safe(h, i, nxt, member) \
508
+ list_for_each_rev_safe_off(h, i, nxt, list_off_var_(i, member))
509
+
510
+ /**
511
+ * list_for_each_safe - iterate through a list, maybe during deletion
512
+ * @h: the list_head
513
+ * @i: the structure containing the list_node
514
+ * @nxt: the structure containing the list_node
515
+ * @member: the list_node member of the structure
516
+ *
517
+ * This is a convenient wrapper to iterate @i over the entire list. It's
518
+ * a for loop, so you can break and continue as normal. The extra variable
519
+ * @nxt is used to hold the next element, so you can delete @i from the list.
520
+ *
521
+ * Example:
522
+ * list_for_each_safe(&parent->children, child, next, list) {
523
+ * list_del(&child->list);
524
+ * parent->num_children--;
525
+ * }
526
+ */
527
+ #define list_for_each_safe(h, i, nxt, member) \
528
+ list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
529
+
530
+ /**
531
+ * list_next - get the next entry in a list
532
+ * @h: the list_head
533
+ * @i: a pointer to an entry in the list.
534
+ * @member: the list_node member of the structure
535
+ *
536
+ * If @i was the last entry in the list, returns NULL.
537
+ *
538
+ * Example:
539
+ * struct child *second;
540
+ * second = list_next(&parent->children, first, list);
541
+ * if (!second)
542
+ * printf("No second child!\n");
543
+ */
544
+ #define list_next(h, i, member) \
545
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
546
+ __FILE__ ":" stringify(__LINE__)), \
547
+ (i)->member.next, \
548
+ list_off_var_((i), member)))
549
+
550
+ /**
551
+ * list_prev - get the previous entry in a list
552
+ * @h: the list_head
553
+ * @i: a pointer to an entry in the list.
554
+ * @member: the list_node member of the structure
555
+ *
556
+ * If @i was the first entry in the list, returns NULL.
557
+ *
558
+ * Example:
559
+ * first = list_prev(&parent->children, second, list);
560
+ * if (!first)
561
+ * printf("Can't go back to first child?!\n");
562
+ */
563
+ #define list_prev(h, i, member) \
564
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
565
+ __FILE__ ":" stringify(__LINE__)), \
566
+ (i)->member.prev, \
567
+ list_off_var_((i), member)))
568
+
569
+ /**
570
+ * list_append_list - empty one list onto the end of another.
571
+ * @to: the list to append into
572
+ * @from: the list to empty.
573
+ *
574
+ * This takes the entire contents of @from and moves it to the end of
575
+ * @to. After this @from will be empty.
576
+ *
577
+ * Example:
578
+ * struct list_head adopter;
579
+ *
580
+ * list_append_list(&adopter, &parent->children);
581
+ * assert(list_empty(&parent->children));
582
+ * parent->num_children = 0;
583
+ */
584
+ #define list_append_list(t, f) list_append_list_(t, f, \
585
+ __FILE__ ":" stringify(__LINE__))
586
+ static inline void list_append_list_(struct list_head *to,
587
+ struct list_head *from,
588
+ const char *abortstr)
589
+ {
590
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
591
+ struct list_node *to_tail = list_debug(to, abortstr)->n.prev;
592
+
593
+ /* Sew in head and entire list. */
594
+ to->n.prev = from_tail;
595
+ from_tail->next = &to->n;
596
+ to_tail->next = &from->n;
597
+ from->n.prev = to_tail;
598
+
599
+ /* Now remove head. */
600
+ list_del(&from->n);
601
+ list_head_init(from);
602
+ }
603
+
604
+ /**
605
+ * list_prepend_list - empty one list into the start of another.
606
+ * @to: the list to prepend into
607
+ * @from: the list to empty.
608
+ *
609
+ * This takes the entire contents of @from and moves it to the start
610
+ * of @to. After this @from will be empty.
611
+ *
612
+ * Example:
613
+ * list_prepend_list(&adopter, &parent->children);
614
+ * assert(list_empty(&parent->children));
615
+ * parent->num_children = 0;
616
+ */
617
+ #define list_prepend_list(t, f) list_prepend_list_(t, f, LIST_LOC)
618
+ static inline void list_prepend_list_(struct list_head *to,
619
+ struct list_head *from,
620
+ const char *abortstr)
621
+ {
622
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
623
+ struct list_node *to_head = list_debug(to, abortstr)->n.next;
624
+
625
+ /* Sew in head and entire list. */
626
+ to->n.next = &from->n;
627
+ from->n.prev = &to->n;
628
+ to_head->prev = from_tail;
629
+ from_tail->next = to_head;
630
+
631
+ /* Now remove head. */
632
+ list_del(&from->n);
633
+ list_head_init(from);
634
+ }
635
+
636
+ /* internal macros, do not use directly */
637
+ #define list_for_each_off_dir_(h, i, off, dir) \
638
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
639
+ (off)); \
640
+ list_node_from_off_((void *)i, (off)) != &(h)->n; \
641
+ i = list_node_to_off_(list_node_from_off_((void *)i, (off))->dir, \
642
+ (off)))
643
+
644
+ #define list_for_each_safe_off_dir_(h, i, nxt, off, dir) \
645
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
646
+ (off)), \
647
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
648
+ (off)); \
649
+ list_node_from_off_(i, (off)) != &(h)->n; \
650
+ i = nxt, \
651
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
652
+ (off)))
653
+
654
+ /**
655
+ * list_for_each_off - iterate through a list of memory regions.
656
+ * @h: the list_head
657
+ * @i: the pointer to a memory region which contains list node data.
658
+ * @off: offset(relative to @i) at which list node data resides.
659
+ *
660
+ * This is a low-level wrapper to iterate @i over the entire list, used to
661
+ * implement all oher, more high-level, for-each constructs. It's a for loop,
662
+ * so you can break and continue as normal.
663
+ *
664
+ * WARNING! Being the low-level macro that it is, this wrapper doesn't know
665
+ * nor care about the type of @i. The only assumption made is that @i points
666
+ * to a chunk of memory that at some @offset, relative to @i, contains a
667
+ * properly filled `struct list_node' which in turn contains pointers to
668
+ * memory chunks and it's turtles all the way down. With all that in mind
669
+ * remember that given the wrong pointer/offset couple this macro will
670
+ * happily churn all you memory until SEGFAULT stops it, in other words
671
+ * caveat emptor.
672
+ *
673
+ * It is worth mentioning that one of legitimate use-cases for that wrapper
674
+ * is operation on opaque types with known offset for `struct list_node'
675
+ * member(preferably 0), because it allows you not to disclose the type of
676
+ * @i.
677
+ *
678
+ * Example:
679
+ * list_for_each_off(&parent->children, child,
680
+ * offsetof(struct child, list))
681
+ * printf("Name: %s\n", child->name);
682
+ */
683
+ #define list_for_each_off(h, i, off) \
684
+ list_for_each_off_dir_((h),(i),(off),next)
685
+
686
+ /**
687
+ * list_for_each_rev_off - iterate through a list of memory regions backwards
688
+ * @h: the list_head
689
+ * @i: the pointer to a memory region which contains list node data.
690
+ * @off: offset(relative to @i) at which list node data resides.
691
+ *
692
+ * See list_for_each_off for details
693
+ */
694
+ #define list_for_each_rev_off(h, i, off) \
695
+ list_for_each_off_dir_((h),(i),(off),prev)
696
+
697
+ /**
698
+ * list_for_each_safe_off - iterate through a list of memory regions, maybe
699
+ * during deletion
700
+ * @h: the list_head
701
+ * @i: the pointer to a memory region which contains list node data.
702
+ * @nxt: the structure containing the list_node
703
+ * @off: offset(relative to @i) at which list node data resides.
704
+ *
705
+ * For details see `list_for_each_off' and `list_for_each_safe'
706
+ * descriptions.
707
+ *
708
+ * Example:
709
+ * list_for_each_safe_off(&parent->children, child,
710
+ * next, offsetof(struct child, list))
711
+ * printf("Name: %s\n", child->name);
712
+ */
713
+ #define list_for_each_safe_off(h, i, nxt, off) \
714
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),next)
715
+
716
+ /**
717
+ * list_for_each_rev_safe_off - iterate backwards through a list of
718
+ * memory regions, maybe during deletion
719
+ * @h: the list_head
720
+ * @i: the pointer to a memory region which contains list node data.
721
+ * @nxt: the structure containing the list_node
722
+ * @off: offset(relative to @i) at which list node data resides.
723
+ *
724
+ * For details see `list_for_each_rev_off' and `list_for_each_rev_safe'
725
+ * descriptions.
726
+ *
727
+ * Example:
728
+ * list_for_each_rev_safe_off(&parent->children, child,
729
+ * next, offsetof(struct child, list))
730
+ * printf("Name: %s\n", child->name);
731
+ */
732
+ #define list_for_each_rev_safe_off(h, i, nxt, off) \
733
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),prev)
734
+
735
+ /* Other -off variants. */
736
+ #define list_entry_off(n, type, off) \
737
+ ((type *)list_node_from_off_((n), (off)))
738
+
739
+ #define list_head_off(h, type, off) \
740
+ ((type *)list_head_off((h), (off)))
741
+
742
+ #define list_tail_off(h, type, off) \
743
+ ((type *)list_tail_((h), (off)))
744
+
745
+ #define list_add_off(h, n, off) \
746
+ list_add((h), list_node_from_off_((n), (off)))
747
+
748
+ #define list_del_off(n, off) \
749
+ list_del(list_node_from_off_((n), (off)))
750
+
751
+ #define list_del_from_off(h, n, off) \
752
+ list_del_from(h, list_node_from_off_((n), (off)))
753
+
754
+ /* Offset helper functions so we only single-evaluate. */
755
+ static inline void *list_node_to_off_(struct list_node *node, size_t off)
756
+ {
757
+ return (void *)((char *)node - off);
758
+ }
759
+ static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
760
+ {
761
+ return (struct list_node *)((char *)ptr + off);
762
+ }
763
+
764
+ /* Get the offset of the member, but make sure it's a list_node. */
765
+ #define list_off_(type, member) \
766
+ (container_off(type, member) + \
767
+ check_type(((type *)0)->member, struct list_node))
768
+
769
+ #define list_off_var_(var, member) \
770
+ (container_off_var(var, member) + \
771
+ check_type(var->member, struct list_node))
772
+
773
+ #if HAVE_TYPEOF
774
+ #define list_typeof(var) typeof(var)
775
+ #else
776
+ #define list_typeof(var) void *
777
+ #endif
778
+
779
+ /* Returns member, or NULL if at end of list. */
780
+ static inline void *list_entry_or_null(const struct list_head *h,
781
+ const struct list_node *n,
782
+ size_t off)
783
+ {
784
+ if (n == &h->n)
785
+ return NULL;
786
+ return (char *)n - off;
787
+ }
788
+ #endif /* CCAN_LIST_H */