debase-ruby_core_source 0.10.2 → 0.10.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (52) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +5 -0
  3. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/addr2line.h +21 -0
  4. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ccan/build_assert/build_assert.h +40 -0
  5. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ccan/check_type/check_type.h +63 -0
  6. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ccan/container_of/container_of.h +142 -0
  7. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ccan/list/list.h +773 -0
  8. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ccan/str/str.h +16 -0
  9. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/constant.h +51 -0
  10. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/debug_counter.h +109 -0
  11. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/dln.h +51 -0
  12. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/encindex.h +69 -0
  13. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/eval_intern.h +334 -0
  14. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/gc.h +116 -0
  15. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/id.h +250 -0
  16. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/id_table.h +31 -0
  17. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/insns.inc +217 -0
  18. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/insns_info.inc +1570 -0
  19. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/internal.h +2036 -0
  20. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/iseq.h +307 -0
  21. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/known_errors.inc +746 -0
  22. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/method.h +218 -0
  23. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/node.h +540 -0
  24. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/node_name.inc +198 -0
  25. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/opt_sc.inc +1601 -0
  26. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/optinsn.inc +103 -0
  27. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/optunifs.inc +61 -0
  28. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/parse.h +206 -0
  29. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/probes_helper.h +43 -0
  30. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/regenc.h +254 -0
  31. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/regint.h +938 -0
  32. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/regparse.h +370 -0
  33. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/revision.h +1 -0
  34. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ruby_assert.h +54 -0
  35. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/ruby_atomic.h +233 -0
  36. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/siphash.h +48 -0
  37. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/symbol.h +108 -0
  38. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/thread_pthread.h +54 -0
  39. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/thread_win32.h +36 -0
  40. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/timev.h +42 -0
  41. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/transcode_data.h +139 -0
  42. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/version.h +73 -0
  43. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm.inc +3667 -0
  44. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_call_iseq_optimized.inc +213 -0
  45. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_core.h +1767 -0
  46. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_debug.h +37 -0
  47. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_exec.h +192 -0
  48. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_insnhelper.h +255 -0
  49. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vm_opts.h +56 -0
  50. data/lib/debase/ruby_core_source/ruby-2.5.1-p57/vmtc.inc +214 -0
  51. data/lib/debase/ruby_core_source/version.rb +1 -1
  52. metadata +51 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: da49613ede517f7ab42266b2ed617056a05b80fe
4
- data.tar.gz: 12393667102d2c2d14ec34f330d405bcc99b0d76
3
+ metadata.gz: c31e00faeec4b76eb5348d45852cd012f29c8fde
4
+ data.tar.gz: f5df3a1d8d7f3cd0dc737f3b6c5880d87bcadf8f
5
5
  SHA512:
6
- metadata.gz: 747e939f5baadcf25675f326d74ff46a318e01059df313fa15155db467d42b7d022c31df96a40e0f7165dd8f09c4659fcb4f492c7d06f3133da9918275fec83a
7
- data.tar.gz: 7ab1f3ed83cd5f6a867528633609dec04287299d4613c56ad8e0179475ae85a5b478677320a0097d5e07c9556e36085bc0f856e47e711ea3dd7477089a70be21
6
+ metadata.gz: b26c10d4ebd5530dc92e346b844ebce6ae1c6d2f3b81cb83a12fc9b675241d19d358ebf6d187fa6553467dae3569a7af68e42a16d92841b4f9171eb53ecc0618
7
+ data.tar.gz: 0cffb7252b32c320793d2b3392c061e02c0ba41d7a41967b5c19d00f295af7d9b83184af324bc17d3bba367e4a33f5acf3937d5f6be73ba061cd839ba1ee78f5
@@ -1,3 +1,8 @@
1
+ ## [0.10.3](https://github.com/os97673/debase-ruby_core_source/compare/v0.10.2...v0.10.3)
2
+
3
+ * ruby 2.5.1 added (contrinuted by [niw](https://github.com/niw))
4
+
5
+
1
6
  ## [0.10.2](https://github.com/os97673/debase-ruby_core_source/compare/v0.10.1...v0.10.2)
2
7
 
3
8
  * ruby 2.5.0 added
@@ -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
+ #ifdef USE_ELF
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,773 @@
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_del - delete an entry from an (unknown) linked list.
242
+ * @n: the list_node to delete from the list.
243
+ *
244
+ * Note that this leaves @n in an undefined state; it can be added to
245
+ * another list, but not deleted again.
246
+ *
247
+ * See also:
248
+ * list_del_from(), list_del_init()
249
+ *
250
+ * Example:
251
+ * list_del(&child->list);
252
+ * parent->num_children--;
253
+ */
254
+ #define list_del(n) list_del_(n, LIST_LOC)
255
+ static inline void list_del_(struct list_node *n, const char* abortstr)
256
+ {
257
+ (void)list_debug_node(n, abortstr);
258
+ n->next->prev = n->prev;
259
+ n->prev->next = n->next;
260
+ #ifdef CCAN_LIST_DEBUG
261
+ /* Catch use-after-del. */
262
+ n->next = n->prev = NULL;
263
+ #endif
264
+ }
265
+
266
+ /**
267
+ * list_del_init - delete a node, and reset it so it can be deleted again.
268
+ * @n: the list_node to be deleted.
269
+ *
270
+ * list_del(@n) or list_del_init() again after this will be safe,
271
+ * which can be useful in some cases.
272
+ *
273
+ * See also:
274
+ * list_del_from(), list_del()
275
+ *
276
+ * Example:
277
+ * list_del_init(&child->list);
278
+ * parent->num_children--;
279
+ */
280
+ #define list_del_init(n) list_del_init_(n, LIST_LOC)
281
+ static inline void list_del_init_(struct list_node *n, const char *abortstr)
282
+ {
283
+ list_del_(n, abortstr);
284
+ list_node_init(n);
285
+ }
286
+
287
+ /**
288
+ * list_del_from - delete an entry from a known linked list.
289
+ * @h: the list_head the node is in.
290
+ * @n: the list_node to delete from the list.
291
+ *
292
+ * This explicitly indicates which list a node is expected to be in,
293
+ * which is better documentation and can catch more bugs.
294
+ *
295
+ * See also: list_del()
296
+ *
297
+ * Example:
298
+ * list_del_from(&parent->children, &child->list);
299
+ * parent->num_children--;
300
+ */
301
+ static inline void list_del_from(struct list_head *h, struct list_node *n)
302
+ {
303
+ #ifdef CCAN_LIST_DEBUG
304
+ {
305
+ /* Thorough check: make sure it was in list! */
306
+ struct list_node *i;
307
+ for (i = h->n.next; i != n; i = i->next)
308
+ assert(i != &h->n);
309
+ }
310
+ #endif /* CCAN_LIST_DEBUG */
311
+
312
+ /* Quick test that catches a surprising number of bugs. */
313
+ assert(!list_empty(h));
314
+ list_del(n);
315
+ }
316
+
317
+ /**
318
+ * list_swap - swap out an entry from an (unknown) linked list for a new one.
319
+ * @o: the list_node to replace from the list.
320
+ * @n: the list_node to insert in place of the old one.
321
+ *
322
+ * Note that this leaves @o in an undefined state; it can be added to
323
+ * another list, but not deleted/swapped again.
324
+ *
325
+ * See also:
326
+ * list_del()
327
+ *
328
+ * Example:
329
+ * struct child x1, x2;
330
+ * LIST_HEAD(xh);
331
+ *
332
+ * list_add(&xh, &x1.list);
333
+ * list_swap(&x1.list, &x2.list);
334
+ */
335
+ #define list_swap(o, n) list_swap_(o, n, LIST_LOC)
336
+ static inline void list_swap_(struct list_node *o,
337
+ struct list_node *n,
338
+ const char* abortstr)
339
+ {
340
+ (void)list_debug_node(o, abortstr);
341
+ *n = *o;
342
+ n->next->prev = n;
343
+ n->prev->next = n;
344
+ #ifdef CCAN_LIST_DEBUG
345
+ /* Catch use-after-del. */
346
+ o->next = o->prev = NULL;
347
+ #endif
348
+ }
349
+
350
+ /**
351
+ * list_entry - convert a list_node back into the structure containing it.
352
+ * @n: the list_node
353
+ * @type: the type of the entry
354
+ * @member: the list_node member of the type
355
+ *
356
+ * Example:
357
+ * // First list entry is children.next; convert back to child.
358
+ * child = list_entry(parent->children.n.next, struct child, list);
359
+ *
360
+ * See Also:
361
+ * list_top(), list_for_each()
362
+ */
363
+ #define list_entry(n, type, member) container_of(n, type, member)
364
+
365
+ /**
366
+ * list_top - get the first entry in a list
367
+ * @h: the list_head
368
+ * @type: the type of the entry
369
+ * @member: the list_node member of the type
370
+ *
371
+ * If the list is empty, returns NULL.
372
+ *
373
+ * Example:
374
+ * struct child *first;
375
+ * first = list_top(&parent->children, struct child, list);
376
+ * if (!first)
377
+ * printf("Empty list!\n");
378
+ */
379
+ #define list_top(h, type, member) \
380
+ ((type *)list_top_((h), list_off_(type, member)))
381
+
382
+ static inline const void *list_top_(const struct list_head *h, size_t off)
383
+ {
384
+ if (list_empty(h))
385
+ return NULL;
386
+ return (const char *)h->n.next - off;
387
+ }
388
+
389
+ /**
390
+ * list_pop - remove the first entry in a list
391
+ * @h: the list_head
392
+ * @type: the type of the entry
393
+ * @member: the list_node member of the type
394
+ *
395
+ * If the list is empty, returns NULL.
396
+ *
397
+ * Example:
398
+ * struct child *one;
399
+ * one = list_pop(&parent->children, struct child, list);
400
+ * if (!one)
401
+ * printf("Empty list!\n");
402
+ */
403
+ #define list_pop(h, type, member) \
404
+ ((type *)list_pop_((h), list_off_(type, member)))
405
+
406
+ static inline const void *list_pop_(const struct list_head *h, size_t off)
407
+ {
408
+ struct list_node *n;
409
+
410
+ if (list_empty(h))
411
+ return NULL;
412
+ n = h->n.next;
413
+ list_del(n);
414
+ return (const char *)n - off;
415
+ }
416
+
417
+ /**
418
+ * list_tail - get the last entry in a list
419
+ * @h: the list_head
420
+ * @type: the type of the entry
421
+ * @member: the list_node member of the type
422
+ *
423
+ * If the list is empty, returns NULL.
424
+ *
425
+ * Example:
426
+ * struct child *last;
427
+ * last = list_tail(&parent->children, struct child, list);
428
+ * if (!last)
429
+ * printf("Empty list!\n");
430
+ */
431
+ #define list_tail(h, type, member) \
432
+ ((type *)list_tail_((h), list_off_(type, member)))
433
+
434
+ static inline const void *list_tail_(const struct list_head *h, size_t off)
435
+ {
436
+ if (list_empty(h))
437
+ return NULL;
438
+ return (const char *)h->n.prev - off;
439
+ }
440
+
441
+ /**
442
+ * list_for_each - iterate through a list.
443
+ * @h: the list_head (warning: evaluated multiple times!)
444
+ * @i: the structure containing the list_node
445
+ * @member: the list_node member of the structure
446
+ *
447
+ * This is a convenient wrapper to iterate @i over the entire list. It's
448
+ * a for loop, so you can break and continue as normal.
449
+ *
450
+ * Example:
451
+ * list_for_each(&parent->children, child, list)
452
+ * printf("Name: %s\n", child->name);
453
+ */
454
+ #define list_for_each(h, i, member) \
455
+ list_for_each_off(h, i, list_off_var_(i, member))
456
+
457
+ /**
458
+ * list_for_each_rev - iterate through a list backwards.
459
+ * @h: the list_head
460
+ * @i: the structure containing the list_node
461
+ * @member: the list_node member of the structure
462
+ *
463
+ * This is a convenient wrapper to iterate @i over the entire list. It's
464
+ * a for loop, so you can break and continue as normal.
465
+ *
466
+ * Example:
467
+ * list_for_each_rev(&parent->children, child, list)
468
+ * printf("Name: %s\n", child->name);
469
+ */
470
+ #define list_for_each_rev(h, i, member) \
471
+ list_for_each_rev_off(h, i, list_off_var_(i, member))
472
+
473
+ /**
474
+ * list_for_each_rev_safe - iterate through a list backwards,
475
+ * maybe during deletion
476
+ * @h: the list_head
477
+ * @i: the structure containing the list_node
478
+ * @nxt: the structure containing the list_node
479
+ * @member: the list_node member of the structure
480
+ *
481
+ * This is a convenient wrapper to iterate @i over the entire list backwards.
482
+ * It's a for loop, so you can break and continue as normal. The extra
483
+ * variable * @nxt is used to hold the next element, so you can delete @i
484
+ * from the list.
485
+ *
486
+ * Example:
487
+ * struct child *next;
488
+ * list_for_each_rev_safe(&parent->children, child, next, list) {
489
+ * printf("Name: %s\n", child->name);
490
+ * }
491
+ */
492
+ #define list_for_each_rev_safe(h, i, nxt, member) \
493
+ list_for_each_rev_safe_off(h, i, nxt, list_off_var_(i, member))
494
+
495
+ /**
496
+ * list_for_each_safe - iterate through a list, maybe during deletion
497
+ * @h: the list_head
498
+ * @i: the structure containing the list_node
499
+ * @nxt: the structure containing the list_node
500
+ * @member: the list_node member of the structure
501
+ *
502
+ * This is a convenient wrapper to iterate @i over the entire list. It's
503
+ * a for loop, so you can break and continue as normal. The extra variable
504
+ * @nxt is used to hold the next element, so you can delete @i from the list.
505
+ *
506
+ * Example:
507
+ * list_for_each_safe(&parent->children, child, next, list) {
508
+ * list_del(&child->list);
509
+ * parent->num_children--;
510
+ * }
511
+ */
512
+ #define list_for_each_safe(h, i, nxt, member) \
513
+ list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
514
+
515
+ /**
516
+ * list_next - get the next entry in a list
517
+ * @h: the list_head
518
+ * @i: a pointer to an entry in the list.
519
+ * @member: the list_node member of the structure
520
+ *
521
+ * If @i was the last entry in the list, returns NULL.
522
+ *
523
+ * Example:
524
+ * struct child *second;
525
+ * second = list_next(&parent->children, first, list);
526
+ * if (!second)
527
+ * printf("No second child!\n");
528
+ */
529
+ #define list_next(h, i, member) \
530
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
531
+ __FILE__ ":" stringify(__LINE__)), \
532
+ (i)->member.next, \
533
+ list_off_var_((i), member)))
534
+
535
+ /**
536
+ * list_prev - get the previous entry in a list
537
+ * @h: the list_head
538
+ * @i: a pointer to an entry in the list.
539
+ * @member: the list_node member of the structure
540
+ *
541
+ * If @i was the first entry in the list, returns NULL.
542
+ *
543
+ * Example:
544
+ * first = list_prev(&parent->children, second, list);
545
+ * if (!first)
546
+ * printf("Can't go back to first child?!\n");
547
+ */
548
+ #define list_prev(h, i, member) \
549
+ ((list_typeof(i))list_entry_or_null(list_debug(h, \
550
+ __FILE__ ":" stringify(__LINE__)), \
551
+ (i)->member.prev, \
552
+ list_off_var_((i), member)))
553
+
554
+ /**
555
+ * list_append_list - empty one list onto the end of another.
556
+ * @to: the list to append into
557
+ * @from: the list to empty.
558
+ *
559
+ * This takes the entire contents of @from and moves it to the end of
560
+ * @to. After this @from will be empty.
561
+ *
562
+ * Example:
563
+ * struct list_head adopter;
564
+ *
565
+ * list_append_list(&adopter, &parent->children);
566
+ * assert(list_empty(&parent->children));
567
+ * parent->num_children = 0;
568
+ */
569
+ #define list_append_list(t, f) list_append_list_(t, f, \
570
+ __FILE__ ":" stringify(__LINE__))
571
+ static inline void list_append_list_(struct list_head *to,
572
+ struct list_head *from,
573
+ const char *abortstr)
574
+ {
575
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
576
+ struct list_node *to_tail = list_debug(to, abortstr)->n.prev;
577
+
578
+ /* Sew in head and entire list. */
579
+ to->n.prev = from_tail;
580
+ from_tail->next = &to->n;
581
+ to_tail->next = &from->n;
582
+ from->n.prev = to_tail;
583
+
584
+ /* Now remove head. */
585
+ list_del(&from->n);
586
+ list_head_init(from);
587
+ }
588
+
589
+ /**
590
+ * list_prepend_list - empty one list into the start of another.
591
+ * @to: the list to prepend into
592
+ * @from: the list to empty.
593
+ *
594
+ * This takes the entire contents of @from and moves it to the start
595
+ * of @to. After this @from will be empty.
596
+ *
597
+ * Example:
598
+ * list_prepend_list(&adopter, &parent->children);
599
+ * assert(list_empty(&parent->children));
600
+ * parent->num_children = 0;
601
+ */
602
+ #define list_prepend_list(t, f) list_prepend_list_(t, f, LIST_LOC)
603
+ static inline void list_prepend_list_(struct list_head *to,
604
+ struct list_head *from,
605
+ const char *abortstr)
606
+ {
607
+ struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
608
+ struct list_node *to_head = list_debug(to, abortstr)->n.next;
609
+
610
+ /* Sew in head and entire list. */
611
+ to->n.next = &from->n;
612
+ from->n.prev = &to->n;
613
+ to_head->prev = from_tail;
614
+ from_tail->next = to_head;
615
+
616
+ /* Now remove head. */
617
+ list_del(&from->n);
618
+ list_head_init(from);
619
+ }
620
+
621
+ /* internal macros, do not use directly */
622
+ #define list_for_each_off_dir_(h, i, off, dir) \
623
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
624
+ (off)); \
625
+ list_node_from_off_((void *)i, (off)) != &(h)->n; \
626
+ i = list_node_to_off_(list_node_from_off_((void *)i, (off))->dir, \
627
+ (off)))
628
+
629
+ #define list_for_each_safe_off_dir_(h, i, nxt, off, dir) \
630
+ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \
631
+ (off)), \
632
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
633
+ (off)); \
634
+ list_node_from_off_(i, (off)) != &(h)->n; \
635
+ i = nxt, \
636
+ nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \
637
+ (off)))
638
+
639
+ /**
640
+ * list_for_each_off - iterate through a list of memory regions.
641
+ * @h: the list_head
642
+ * @i: the pointer to a memory region wich contains list node data.
643
+ * @off: offset(relative to @i) at which list node data resides.
644
+ *
645
+ * This is a low-level wrapper to iterate @i over the entire list, used to
646
+ * implement all oher, more high-level, for-each constructs. It's a for loop,
647
+ * so you can break and continue as normal.
648
+ *
649
+ * WARNING! Being the low-level macro that it is, this wrapper doesn't know
650
+ * nor care about the type of @i. The only assumtion made is that @i points
651
+ * to a chunk of memory that at some @offset, relative to @i, contains a
652
+ * properly filled `struct node_list' which in turn contains pointers to
653
+ * memory chunks and it's turtles all the way down. Whith all that in mind
654
+ * remember that given the wrong pointer/offset couple this macro will
655
+ * happilly churn all you memory untill SEGFAULT stops it, in other words
656
+ * caveat emptor.
657
+ *
658
+ * It is worth mentioning that one of legitimate use-cases for that wrapper
659
+ * is operation on opaque types with known offset for `struct list_node'
660
+ * member(preferably 0), because it allows you not to disclose the type of
661
+ * @i.
662
+ *
663
+ * Example:
664
+ * list_for_each_off(&parent->children, child,
665
+ * offsetof(struct child, list))
666
+ * printf("Name: %s\n", child->name);
667
+ */
668
+ #define list_for_each_off(h, i, off) \
669
+ list_for_each_off_dir_((h),(i),(off),next)
670
+
671
+ /**
672
+ * list_for_each_rev_off - iterate through a list of memory regions backwards
673
+ * @h: the list_head
674
+ * @i: the pointer to a memory region wich contains list node data.
675
+ * @off: offset(relative to @i) at which list node data resides.
676
+ *
677
+ * See list_for_each_off for details
678
+ */
679
+ #define list_for_each_rev_off(h, i, off) \
680
+ list_for_each_off_dir_((h),(i),(off),prev)
681
+
682
+ /**
683
+ * list_for_each_safe_off - iterate through a list of memory regions, maybe
684
+ * during deletion
685
+ * @h: the list_head
686
+ * @i: the pointer to a memory region wich contains list node data.
687
+ * @nxt: the structure containing the list_node
688
+ * @off: offset(relative to @i) at which list node data resides.
689
+ *
690
+ * For details see `list_for_each_off' and `list_for_each_safe'
691
+ * descriptions.
692
+ *
693
+ * Example:
694
+ * list_for_each_safe_off(&parent->children, child,
695
+ * next, offsetof(struct child, list))
696
+ * printf("Name: %s\n", child->name);
697
+ */
698
+ #define list_for_each_safe_off(h, i, nxt, off) \
699
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),next)
700
+
701
+ /**
702
+ * list_for_each_rev_safe_off - iterate backwards through a list of
703
+ * memory regions, maybe during deletion
704
+ * @h: the list_head
705
+ * @i: the pointer to a memory region wich contains list node data.
706
+ * @nxt: the structure containing the list_node
707
+ * @off: offset(relative to @i) at which list node data resides.
708
+ *
709
+ * For details see `list_for_each_rev_off' and `list_for_each_rev_safe'
710
+ * descriptions.
711
+ *
712
+ * Example:
713
+ * list_for_each_rev_safe_off(&parent->children, child,
714
+ * next, offsetof(struct child, list))
715
+ * printf("Name: %s\n", child->name);
716
+ */
717
+ #define list_for_each_rev_safe_off(h, i, nxt, off) \
718
+ list_for_each_safe_off_dir_((h),(i),(nxt),(off),prev)
719
+
720
+ /* Other -off variants. */
721
+ #define list_entry_off(n, type, off) \
722
+ ((type *)list_node_from_off_((n), (off)))
723
+
724
+ #define list_head_off(h, type, off) \
725
+ ((type *)list_head_off((h), (off)))
726
+
727
+ #define list_tail_off(h, type, off) \
728
+ ((type *)list_tail_((h), (off)))
729
+
730
+ #define list_add_off(h, n, off) \
731
+ list_add((h), list_node_from_off_((n), (off)))
732
+
733
+ #define list_del_off(n, off) \
734
+ list_del(list_node_from_off_((n), (off)))
735
+
736
+ #define list_del_from_off(h, n, off) \
737
+ list_del_from(h, list_node_from_off_((n), (off)))
738
+
739
+ /* Offset helper functions so we only single-evaluate. */
740
+ static inline void *list_node_to_off_(struct list_node *node, size_t off)
741
+ {
742
+ return (void *)((char *)node - off);
743
+ }
744
+ static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
745
+ {
746
+ return (struct list_node *)((char *)ptr + off);
747
+ }
748
+
749
+ /* Get the offset of the member, but make sure it's a list_node. */
750
+ #define list_off_(type, member) \
751
+ (container_off(type, member) + \
752
+ check_type(((type *)0)->member, struct list_node))
753
+
754
+ #define list_off_var_(var, member) \
755
+ (container_off_var(var, member) + \
756
+ check_type(var->member, struct list_node))
757
+
758
+ #if HAVE_TYPEOF
759
+ #define list_typeof(var) typeof(var)
760
+ #else
761
+ #define list_typeof(var) void *
762
+ #endif
763
+
764
+ /* Returns member, or NULL if at end of list. */
765
+ static inline void *list_entry_or_null(const struct list_head *h,
766
+ const struct list_node *n,
767
+ size_t off)
768
+ {
769
+ if (n == &h->n)
770
+ return NULL;
771
+ return (char *)n - off;
772
+ }
773
+ #endif /* CCAN_LIST_H */