debase-ruby_core_source 0.7.5 → 0.7.6
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG.md +4 -0
- data/CONTRIBUTING.md +2 -1
- data/Rakefile +3 -2
- data/lib/debase/ruby_core_source/ruby-2.2.1/addr2line.h +21 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/build_assert/build_assert.h +40 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/check_type/check_type.h +63 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/container_of/container_of.h +142 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/list/list.h +635 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/str/str.h +16 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/constant.h +43 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/dln.h +51 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/eval_intern.h +275 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/gc.h +107 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/id.h +210 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/insns.inc +107 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/insns_info.inc +752 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/internal.h +1185 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/iseq.h +158 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/known_errors.inc +746 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/method.h +144 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/node.h +544 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/node_name.inc +212 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/opt_sc.inc +734 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/optinsn.inc +83 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/optunifs.inc +124 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/parse.h +203 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/probes_helper.h +67 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/regenc.h +234 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/regint.h +972 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/regparse.h +363 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/revision.h +1 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/ruby_atomic.h +170 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/siphash.h +48 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/symbol.h +87 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/thread_pthread.h +54 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/thread_win32.h +36 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/timev.h +42 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/transcode_data.h +123 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/version.h +52 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm.inc +3353 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm_core.h +1161 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm_debug.h +37 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm_exec.h +182 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm_insnhelper.h +233 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vm_opts.h +56 -0
- data/lib/debase/ruby_core_source/ruby-2.2.1/vmtc.inc +105 -0
- data/lib/debase/ruby_core_source/version.rb +1 -1
- metadata +45 -2
@@ -0,0 +1,635 @@
|
|
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) (h)
|
46
|
+
#define list_debug_node(n, 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 - add an entry at the start of a linked list.
|
108
|
+
* @h: the list_head to add the node to
|
109
|
+
* @n: the list_node to add to the list.
|
110
|
+
*
|
111
|
+
* The list_node does not need to be initialized; it will be overwritten.
|
112
|
+
* Example:
|
113
|
+
* struct child *child = malloc(sizeof(*child));
|
114
|
+
*
|
115
|
+
* child->name = "marvin";
|
116
|
+
* list_add(&parent->children, &child->list);
|
117
|
+
* parent->num_children++;
|
118
|
+
*/
|
119
|
+
#define list_add(h, n) list_add_(h, n, LIST_LOC)
|
120
|
+
static inline void list_add_(struct list_head *h,
|
121
|
+
struct list_node *n,
|
122
|
+
const char *abortstr)
|
123
|
+
{
|
124
|
+
n->next = h->n.next;
|
125
|
+
n->prev = &h->n;
|
126
|
+
h->n.next->prev = n;
|
127
|
+
h->n.next = n;
|
128
|
+
(void)list_debug(h, abortstr);
|
129
|
+
}
|
130
|
+
|
131
|
+
/**
|
132
|
+
* list_add_tail - add an entry at the end of a linked list.
|
133
|
+
* @h: the list_head to add the node to
|
134
|
+
* @n: the list_node to add to the list.
|
135
|
+
*
|
136
|
+
* The list_node does not need to be initialized; it will be overwritten.
|
137
|
+
* Example:
|
138
|
+
* list_add_tail(&parent->children, &child->list);
|
139
|
+
* parent->num_children++;
|
140
|
+
*/
|
141
|
+
#define list_add_tail(h, n) list_add_tail_(h, n, LIST_LOC)
|
142
|
+
static inline void list_add_tail_(struct list_head *h,
|
143
|
+
struct list_node *n,
|
144
|
+
const char *abortstr)
|
145
|
+
{
|
146
|
+
n->next = &h->n;
|
147
|
+
n->prev = h->n.prev;
|
148
|
+
h->n.prev->next = n;
|
149
|
+
h->n.prev = n;
|
150
|
+
(void)list_debug(h, abortstr);
|
151
|
+
}
|
152
|
+
|
153
|
+
/**
|
154
|
+
* list_empty - is a list empty?
|
155
|
+
* @h: the list_head
|
156
|
+
*
|
157
|
+
* If the list is empty, returns true.
|
158
|
+
*
|
159
|
+
* Example:
|
160
|
+
* assert(list_empty(&parent->children) == (parent->num_children == 0));
|
161
|
+
*/
|
162
|
+
#define list_empty(h) list_empty_(h, LIST_LOC)
|
163
|
+
static inline int list_empty_(const struct list_head *h, const char* abortstr)
|
164
|
+
{
|
165
|
+
(void)list_debug(h, abortstr);
|
166
|
+
return h->n.next == &h->n;
|
167
|
+
}
|
168
|
+
|
169
|
+
/**
|
170
|
+
* list_empty_nodebug - is a list empty (and don't perform debug checks)?
|
171
|
+
* @h: the list_head
|
172
|
+
*
|
173
|
+
* If the list is empty, returns true.
|
174
|
+
* This differs from list_empty() in that if CCAN_LIST_DEBUG is set it
|
175
|
+
* will NOT perform debug checks. Only use this function if you REALLY
|
176
|
+
* know what you're doing.
|
177
|
+
*
|
178
|
+
* Example:
|
179
|
+
* assert(list_empty_nodebug(&parent->children) == (parent->num_children == 0));
|
180
|
+
*/
|
181
|
+
#ifndef CCAN_LIST_DEBUG
|
182
|
+
#define list_empty_nodebug(h) list_empty(h)
|
183
|
+
#else
|
184
|
+
static inline int list_empty_nodebug(const struct list_head *h)
|
185
|
+
{
|
186
|
+
return h->n.next == &h->n;
|
187
|
+
}
|
188
|
+
#endif
|
189
|
+
|
190
|
+
/**
|
191
|
+
* list_del - delete an entry from an (unknown) linked list.
|
192
|
+
* @n: the list_node to delete from the list.
|
193
|
+
*
|
194
|
+
* Note that this leaves @n in an undefined state; it can be added to
|
195
|
+
* another list, but not deleted again.
|
196
|
+
*
|
197
|
+
* See also:
|
198
|
+
* list_del_from(), list_del_init()
|
199
|
+
*
|
200
|
+
* Example:
|
201
|
+
* list_del(&child->list);
|
202
|
+
* parent->num_children--;
|
203
|
+
*/
|
204
|
+
#define list_del(n) list_del_(n, LIST_LOC)
|
205
|
+
static inline void list_del_(struct list_node *n, const char* abortstr)
|
206
|
+
{
|
207
|
+
(void)list_debug_node(n, abortstr);
|
208
|
+
n->next->prev = n->prev;
|
209
|
+
n->prev->next = n->next;
|
210
|
+
#ifdef CCAN_LIST_DEBUG
|
211
|
+
/* Catch use-after-del. */
|
212
|
+
n->next = n->prev = NULL;
|
213
|
+
#endif
|
214
|
+
}
|
215
|
+
|
216
|
+
/**
|
217
|
+
* list_del_init - delete a node, and reset it so it can be deleted again.
|
218
|
+
* @n: the list_node to be deleted.
|
219
|
+
*
|
220
|
+
* list_del(@n) or list_del_init() again after this will be safe,
|
221
|
+
* which can be useful in some cases.
|
222
|
+
*
|
223
|
+
* See also:
|
224
|
+
* list_del_from(), list_del()
|
225
|
+
*
|
226
|
+
* Example:
|
227
|
+
* list_del_init(&child->list);
|
228
|
+
* parent->num_children--;
|
229
|
+
*/
|
230
|
+
#define list_del_init(n) list_del_init_(n, LIST_LOC)
|
231
|
+
static inline void list_del_init_(struct list_node *n, const char *abortstr)
|
232
|
+
{
|
233
|
+
list_del_(n, abortstr);
|
234
|
+
list_node_init(n);
|
235
|
+
}
|
236
|
+
|
237
|
+
/**
|
238
|
+
* list_del_from - delete an entry from a known linked list.
|
239
|
+
* @h: the list_head the node is in.
|
240
|
+
* @n: the list_node to delete from the list.
|
241
|
+
*
|
242
|
+
* This explicitly indicates which list a node is expected to be in,
|
243
|
+
* which is better documentation and can catch more bugs.
|
244
|
+
*
|
245
|
+
* See also: list_del()
|
246
|
+
*
|
247
|
+
* Example:
|
248
|
+
* list_del_from(&parent->children, &child->list);
|
249
|
+
* parent->num_children--;
|
250
|
+
*/
|
251
|
+
static inline void list_del_from(struct list_head *h, struct list_node *n)
|
252
|
+
{
|
253
|
+
#ifdef CCAN_LIST_DEBUG
|
254
|
+
{
|
255
|
+
/* Thorough check: make sure it was in list! */
|
256
|
+
struct list_node *i;
|
257
|
+
for (i = h->n.next; i != n; i = i->next)
|
258
|
+
assert(i != &h->n);
|
259
|
+
}
|
260
|
+
#endif /* CCAN_LIST_DEBUG */
|
261
|
+
|
262
|
+
/* Quick test that catches a surprising number of bugs. */
|
263
|
+
assert(!list_empty(h));
|
264
|
+
list_del(n);
|
265
|
+
}
|
266
|
+
|
267
|
+
/**
|
268
|
+
* list_entry - convert a list_node back into the structure containing it.
|
269
|
+
* @n: the list_node
|
270
|
+
* @type: the type of the entry
|
271
|
+
* @member: the list_node member of the type
|
272
|
+
*
|
273
|
+
* Example:
|
274
|
+
* // First list entry is children.next; convert back to child.
|
275
|
+
* child = list_entry(parent->children.n.next, struct child, list);
|
276
|
+
*
|
277
|
+
* See Also:
|
278
|
+
* list_top(), list_for_each()
|
279
|
+
*/
|
280
|
+
#define list_entry(n, type, member) container_of(n, type, member)
|
281
|
+
|
282
|
+
/**
|
283
|
+
* list_top - get the first entry in a list
|
284
|
+
* @h: the list_head
|
285
|
+
* @type: the type of the entry
|
286
|
+
* @member: the list_node member of the type
|
287
|
+
*
|
288
|
+
* If the list is empty, returns NULL.
|
289
|
+
*
|
290
|
+
* Example:
|
291
|
+
* struct child *first;
|
292
|
+
* first = list_top(&parent->children, struct child, list);
|
293
|
+
* if (!first)
|
294
|
+
* printf("Empty list!\n");
|
295
|
+
*/
|
296
|
+
#define list_top(h, type, member) \
|
297
|
+
((type *)list_top_((h), list_off_(type, member)))
|
298
|
+
|
299
|
+
static inline const void *list_top_(const struct list_head *h, size_t off)
|
300
|
+
{
|
301
|
+
if (list_empty(h))
|
302
|
+
return NULL;
|
303
|
+
return (const char *)h->n.next - off;
|
304
|
+
}
|
305
|
+
|
306
|
+
/**
|
307
|
+
* list_pop - remove the first entry in a list
|
308
|
+
* @h: the list_head
|
309
|
+
* @type: the type of the entry
|
310
|
+
* @member: the list_node member of the type
|
311
|
+
*
|
312
|
+
* If the list is empty, returns NULL.
|
313
|
+
*
|
314
|
+
* Example:
|
315
|
+
* struct child *one;
|
316
|
+
* one = list_pop(&parent->children, struct child, list);
|
317
|
+
* if (!one)
|
318
|
+
* printf("Empty list!\n");
|
319
|
+
*/
|
320
|
+
#define list_pop(h, type, member) \
|
321
|
+
((type *)list_pop_((h), list_off_(type, member)))
|
322
|
+
|
323
|
+
static inline const void *list_pop_(const struct list_head *h, size_t off)
|
324
|
+
{
|
325
|
+
struct list_node *n;
|
326
|
+
|
327
|
+
if (list_empty(h))
|
328
|
+
return NULL;
|
329
|
+
n = h->n.next;
|
330
|
+
list_del(n);
|
331
|
+
return (const char *)n - off;
|
332
|
+
}
|
333
|
+
|
334
|
+
/**
|
335
|
+
* list_tail - get the last entry in a list
|
336
|
+
* @h: the list_head
|
337
|
+
* @type: the type of the entry
|
338
|
+
* @member: the list_node member of the type
|
339
|
+
*
|
340
|
+
* If the list is empty, returns NULL.
|
341
|
+
*
|
342
|
+
* Example:
|
343
|
+
* struct child *last;
|
344
|
+
* last = list_tail(&parent->children, struct child, list);
|
345
|
+
* if (!last)
|
346
|
+
* printf("Empty list!\n");
|
347
|
+
*/
|
348
|
+
#define list_tail(h, type, member) \
|
349
|
+
((type *)list_tail_((h), list_off_(type, member)))
|
350
|
+
|
351
|
+
static inline const void *list_tail_(const struct list_head *h, size_t off)
|
352
|
+
{
|
353
|
+
if (list_empty(h))
|
354
|
+
return NULL;
|
355
|
+
return (const char *)h->n.prev - off;
|
356
|
+
}
|
357
|
+
|
358
|
+
/**
|
359
|
+
* list_for_each - iterate through a list.
|
360
|
+
* @h: the list_head (warning: evaluated multiple times!)
|
361
|
+
* @i: the structure containing the list_node
|
362
|
+
* @member: the list_node member of the structure
|
363
|
+
*
|
364
|
+
* This is a convenient wrapper to iterate @i over the entire list. It's
|
365
|
+
* a for loop, so you can break and continue as normal.
|
366
|
+
*
|
367
|
+
* Example:
|
368
|
+
* list_for_each(&parent->children, child, list)
|
369
|
+
* printf("Name: %s\n", child->name);
|
370
|
+
*/
|
371
|
+
#define list_for_each(h, i, member) \
|
372
|
+
list_for_each_off(h, i, list_off_var_(i, member))
|
373
|
+
|
374
|
+
/**
|
375
|
+
* list_for_each_rev - iterate through a list backwards.
|
376
|
+
* @h: the list_head
|
377
|
+
* @i: the structure containing the list_node
|
378
|
+
* @member: the list_node member of the structure
|
379
|
+
*
|
380
|
+
* This is a convenient wrapper to iterate @i over the entire list. It's
|
381
|
+
* a for loop, so you can break and continue as normal.
|
382
|
+
*
|
383
|
+
* Example:
|
384
|
+
* list_for_each_rev(&parent->children, child, list)
|
385
|
+
* printf("Name: %s\n", child->name);
|
386
|
+
*/
|
387
|
+
#define list_for_each_rev(h, i, member) \
|
388
|
+
for (i = container_of_var(list_debug(h, LIST_LOC)->n.prev, i, member); \
|
389
|
+
&i->member != &(h)->n; \
|
390
|
+
i = container_of_var(i->member.prev, i, member))
|
391
|
+
|
392
|
+
/**
|
393
|
+
* list_for_each_safe - iterate through a list, maybe during deletion
|
394
|
+
* @h: the list_head
|
395
|
+
* @i: the structure containing the list_node
|
396
|
+
* @nxt: the structure containing the list_node
|
397
|
+
* @member: the list_node member of the structure
|
398
|
+
*
|
399
|
+
* This is a convenient wrapper to iterate @i over the entire list. It's
|
400
|
+
* a for loop, so you can break and continue as normal. The extra variable
|
401
|
+
* @nxt is used to hold the next element, so you can delete @i from the list.
|
402
|
+
*
|
403
|
+
* Example:
|
404
|
+
* struct child *next;
|
405
|
+
* list_for_each_safe(&parent->children, child, next, list) {
|
406
|
+
* list_del(&child->list);
|
407
|
+
* parent->num_children--;
|
408
|
+
* }
|
409
|
+
*/
|
410
|
+
#define list_for_each_safe(h, i, nxt, member) \
|
411
|
+
list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
|
412
|
+
|
413
|
+
/**
|
414
|
+
* list_next - get the next entry in a list
|
415
|
+
* @h: the list_head
|
416
|
+
* @i: a pointer to an entry in the list.
|
417
|
+
* @member: the list_node member of the structure
|
418
|
+
*
|
419
|
+
* If @i was the last entry in the list, returns NULL.
|
420
|
+
*
|
421
|
+
* Example:
|
422
|
+
* struct child *second;
|
423
|
+
* second = list_next(&parent->children, first, list);
|
424
|
+
* if (!second)
|
425
|
+
* printf("No second child!\n");
|
426
|
+
*/
|
427
|
+
#define list_next(h, i, member) \
|
428
|
+
((list_typeof(i))list_entry_or_null(list_debug(h, \
|
429
|
+
__FILE__ ":" stringify(__LINE__)), \
|
430
|
+
(i)->member.next, \
|
431
|
+
list_off_var_((i), member)))
|
432
|
+
|
433
|
+
/**
|
434
|
+
* list_prev - get the previous entry in a list
|
435
|
+
* @h: the list_head
|
436
|
+
* @i: a pointer to an entry in the list.
|
437
|
+
* @member: the list_node member of the structure
|
438
|
+
*
|
439
|
+
* If @i was the first entry in the list, returns NULL.
|
440
|
+
*
|
441
|
+
* Example:
|
442
|
+
* first = list_prev(&parent->children, second, list);
|
443
|
+
* if (!first)
|
444
|
+
* printf("Can't go back to first child?!\n");
|
445
|
+
*/
|
446
|
+
#define list_prev(h, i, member) \
|
447
|
+
((list_typeof(i))list_entry_or_null(list_debug(h, \
|
448
|
+
__FILE__ ":" stringify(__LINE__)), \
|
449
|
+
(i)->member.prev, \
|
450
|
+
list_off_var_((i), member)))
|
451
|
+
|
452
|
+
/**
|
453
|
+
* list_append_list - empty one list onto the end of another.
|
454
|
+
* @to: the list to append into
|
455
|
+
* @from: the list to empty.
|
456
|
+
*
|
457
|
+
* This takes the entire contents of @from and moves it to the end of
|
458
|
+
* @to. After this @from will be empty.
|
459
|
+
*
|
460
|
+
* Example:
|
461
|
+
* struct list_head adopter;
|
462
|
+
*
|
463
|
+
* list_append_list(&adopter, &parent->children);
|
464
|
+
* assert(list_empty(&parent->children));
|
465
|
+
* parent->num_children = 0;
|
466
|
+
*/
|
467
|
+
#define list_append_list(t, f) list_append_list_(t, f, \
|
468
|
+
__FILE__ ":" stringify(__LINE__))
|
469
|
+
static inline void list_append_list_(struct list_head *to,
|
470
|
+
struct list_head *from,
|
471
|
+
const char *abortstr)
|
472
|
+
{
|
473
|
+
struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
|
474
|
+
struct list_node *to_tail = list_debug(to, abortstr)->n.prev;
|
475
|
+
|
476
|
+
/* Sew in head and entire list. */
|
477
|
+
to->n.prev = from_tail;
|
478
|
+
from_tail->next = &to->n;
|
479
|
+
to_tail->next = &from->n;
|
480
|
+
from->n.prev = to_tail;
|
481
|
+
|
482
|
+
/* Now remove head. */
|
483
|
+
list_del(&from->n);
|
484
|
+
list_head_init(from);
|
485
|
+
}
|
486
|
+
|
487
|
+
/**
|
488
|
+
* list_prepend_list - empty one list into the start of another.
|
489
|
+
* @to: the list to prepend into
|
490
|
+
* @from: the list to empty.
|
491
|
+
*
|
492
|
+
* This takes the entire contents of @from and moves it to the start
|
493
|
+
* of @to. After this @from will be empty.
|
494
|
+
*
|
495
|
+
* Example:
|
496
|
+
* list_prepend_list(&adopter, &parent->children);
|
497
|
+
* assert(list_empty(&parent->children));
|
498
|
+
* parent->num_children = 0;
|
499
|
+
*/
|
500
|
+
#define list_prepend_list(t, f) list_prepend_list_(t, f, LIST_LOC)
|
501
|
+
static inline void list_prepend_list_(struct list_head *to,
|
502
|
+
struct list_head *from,
|
503
|
+
const char *abortstr)
|
504
|
+
{
|
505
|
+
struct list_node *from_tail = list_debug(from, abortstr)->n.prev;
|
506
|
+
struct list_node *to_head = list_debug(to, abortstr)->n.next;
|
507
|
+
|
508
|
+
/* Sew in head and entire list. */
|
509
|
+
to->n.next = &from->n;
|
510
|
+
from->n.prev = &to->n;
|
511
|
+
to_head->prev = from_tail;
|
512
|
+
from_tail->next = to_head;
|
513
|
+
|
514
|
+
/* Now remove head. */
|
515
|
+
list_del(&from->n);
|
516
|
+
list_head_init(from);
|
517
|
+
}
|
518
|
+
|
519
|
+
/**
|
520
|
+
* list_for_each_off - iterate through a list of memory regions.
|
521
|
+
* @h: the list_head
|
522
|
+
* @i: the pointer to a memory region wich contains list node data.
|
523
|
+
* @off: offset(relative to @i) at which list node data resides.
|
524
|
+
*
|
525
|
+
* This is a low-level wrapper to iterate @i over the entire list, used to
|
526
|
+
* implement all oher, more high-level, for-each constructs. It's a for loop,
|
527
|
+
* so you can break and continue as normal.
|
528
|
+
*
|
529
|
+
* WARNING! Being the low-level macro that it is, this wrapper doesn't know
|
530
|
+
* nor care about the type of @i. The only assumtion made is that @i points
|
531
|
+
* to a chunk of memory that at some @offset, relative to @i, contains a
|
532
|
+
* properly filled `struct node_list' which in turn contains pointers to
|
533
|
+
* memory chunks and it's turtles all the way down. Whith all that in mind
|
534
|
+
* remember that given the wrong pointer/offset couple this macro will
|
535
|
+
* happilly churn all you memory untill SEGFAULT stops it, in other words
|
536
|
+
* caveat emptor.
|
537
|
+
*
|
538
|
+
* It is worth mentioning that one of legitimate use-cases for that wrapper
|
539
|
+
* is operation on opaque types with known offset for `struct list_node'
|
540
|
+
* member(preferably 0), because it allows you not to disclose the type of
|
541
|
+
* @i.
|
542
|
+
*
|
543
|
+
* Example:
|
544
|
+
* list_for_each_off(&parent->children, child,
|
545
|
+
* offsetof(struct child, list))
|
546
|
+
* printf("Name: %s\n", child->name);
|
547
|
+
*/
|
548
|
+
#define list_for_each_off(h, i, off) \
|
549
|
+
for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.next, \
|
550
|
+
(off)); \
|
551
|
+
list_node_from_off_((void *)i, (off)) != &(h)->n; \
|
552
|
+
i = list_node_to_off_(list_node_from_off_((void *)i, (off))->next, \
|
553
|
+
(off)))
|
554
|
+
|
555
|
+
/**
|
556
|
+
* list_for_each_safe_off - iterate through a list of memory regions, maybe
|
557
|
+
* during deletion
|
558
|
+
* @h: the list_head
|
559
|
+
* @i: the pointer to a memory region wich contains list node data.
|
560
|
+
* @nxt: the structure containing the list_node
|
561
|
+
* @off: offset(relative to @i) at which list node data resides.
|
562
|
+
*
|
563
|
+
* For details see `list_for_each_off' and `list_for_each_safe'
|
564
|
+
* descriptions.
|
565
|
+
*
|
566
|
+
* Example:
|
567
|
+
* list_for_each_safe_off(&parent->children, child,
|
568
|
+
* next, offsetof(struct child, list))
|
569
|
+
* printf("Name: %s\n", child->name);
|
570
|
+
*/
|
571
|
+
#define list_for_each_safe_off(h, i, nxt, off) \
|
572
|
+
for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.next, \
|
573
|
+
(off)), \
|
574
|
+
nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
|
575
|
+
(off)); \
|
576
|
+
list_node_from_off_(i, (off)) != &(h)->n; \
|
577
|
+
i = nxt, \
|
578
|
+
nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
|
579
|
+
(off)))
|
580
|
+
|
581
|
+
|
582
|
+
/* Other -off variants. */
|
583
|
+
#define list_entry_off(n, type, off) \
|
584
|
+
((type *)list_node_from_off_((n), (off)))
|
585
|
+
|
586
|
+
#define list_head_off(h, type, off) \
|
587
|
+
((type *)list_head_off((h), (off)))
|
588
|
+
|
589
|
+
#define list_tail_off(h, type, off) \
|
590
|
+
((type *)list_tail_((h), (off)))
|
591
|
+
|
592
|
+
#define list_add_off(h, n, off) \
|
593
|
+
list_add((h), list_node_from_off_((n), (off)))
|
594
|
+
|
595
|
+
#define list_del_off(n, off) \
|
596
|
+
list_del(list_node_from_off_((n), (off)))
|
597
|
+
|
598
|
+
#define list_del_from_off(h, n, off) \
|
599
|
+
list_del_from(h, list_node_from_off_((n), (off)))
|
600
|
+
|
601
|
+
/* Offset helper functions so we only single-evaluate. */
|
602
|
+
static inline void *list_node_to_off_(struct list_node *node, size_t off)
|
603
|
+
{
|
604
|
+
return (void *)((char *)node - off);
|
605
|
+
}
|
606
|
+
static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
|
607
|
+
{
|
608
|
+
return (struct list_node *)((char *)ptr + off);
|
609
|
+
}
|
610
|
+
|
611
|
+
/* Get the offset of the member, but make sure it's a list_node. */
|
612
|
+
#define list_off_(type, member) \
|
613
|
+
(container_off(type, member) + \
|
614
|
+
check_type(((type *)0)->member, struct list_node))
|
615
|
+
|
616
|
+
#define list_off_var_(var, member) \
|
617
|
+
(container_off_var(var, member) + \
|
618
|
+
check_type(var->member, struct list_node))
|
619
|
+
|
620
|
+
#if HAVE_TYPEOF
|
621
|
+
#define list_typeof(var) typeof(var)
|
622
|
+
#else
|
623
|
+
#define list_typeof(var) void *
|
624
|
+
#endif
|
625
|
+
|
626
|
+
/* Returns member, or NULL if at end of list. */
|
627
|
+
static inline void *list_entry_or_null(const struct list_head *h,
|
628
|
+
const struct list_node *n,
|
629
|
+
size_t off)
|
630
|
+
{
|
631
|
+
if (n == &h->n)
|
632
|
+
return NULL;
|
633
|
+
return (char *)n - off;
|
634
|
+
}
|
635
|
+
#endif /* CCAN_LIST_H */
|
@@ -0,0 +1,16 @@
|
|
1
|
+
/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
|
2
|
+
#ifndef CCAN_STR_H
|
3
|
+
#define CCAN_STR_H
|
4
|
+
/**
|
5
|
+
* stringify - Turn expression into a string literal
|
6
|
+
* @expr: any C expression
|
7
|
+
*
|
8
|
+
* Example:
|
9
|
+
* #define PRINT_COND_IF_FALSE(cond) \
|
10
|
+
* ((cond) || printf("%s is false!", stringify(cond)))
|
11
|
+
*/
|
12
|
+
#define stringify(expr) stringify_1(expr)
|
13
|
+
/* Double-indirection required to stringify expansions */
|
14
|
+
#define stringify_1(expr) #expr
|
15
|
+
|
16
|
+
#endif /* CCAN_STR_H */
|
@@ -0,0 +1,43 @@
|
|
1
|
+
/**********************************************************************
|
2
|
+
|
3
|
+
constant.h -
|
4
|
+
|
5
|
+
$Author$
|
6
|
+
created at: Sun Nov 15 00:09:33 2009
|
7
|
+
|
8
|
+
Copyright (C) 2009 Yusuke Endoh
|
9
|
+
|
10
|
+
**********************************************************************/
|
11
|
+
#ifndef CONSTANT_H
|
12
|
+
#define CONSTANT_H
|
13
|
+
|
14
|
+
typedef enum {
|
15
|
+
CONST_PUBLIC = 0x00,
|
16
|
+
CONST_PRIVATE,
|
17
|
+
CONST_VISIBILITY_MAX
|
18
|
+
} rb_const_flag_t;
|
19
|
+
|
20
|
+
#define RB_CONST_PRIVATE_P(ce) \
|
21
|
+
((ce)->flag == CONST_PRIVATE)
|
22
|
+
#define RB_CONST_PUBLIC_P(ce) \
|
23
|
+
((ce)->flag == CONST_PUBLIC)
|
24
|
+
|
25
|
+
typedef struct rb_const_entry_struct {
|
26
|
+
rb_const_flag_t flag;
|
27
|
+
int line;
|
28
|
+
const VALUE value; /* should be mark */
|
29
|
+
const VALUE file; /* should be mark */
|
30
|
+
} rb_const_entry_t;
|
31
|
+
|
32
|
+
VALUE rb_mod_private_constant(int argc, const VALUE *argv, VALUE obj);
|
33
|
+
VALUE rb_mod_public_constant(int argc, const VALUE *argv, VALUE obj);
|
34
|
+
void rb_free_const_table(st_table *tbl);
|
35
|
+
VALUE rb_public_const_get(VALUE klass, ID id);
|
36
|
+
VALUE rb_public_const_get_at(VALUE klass, ID id);
|
37
|
+
VALUE rb_public_const_get_from(VALUE klass, ID id);
|
38
|
+
int rb_public_const_defined(VALUE klass, ID id);
|
39
|
+
int rb_public_const_defined_at(VALUE klass, ID id);
|
40
|
+
int rb_public_const_defined_from(VALUE klass, ID id);
|
41
|
+
rb_const_entry_t *rb_const_lookup(VALUE klass, ID id);
|
42
|
+
|
43
|
+
#endif /* CONSTANT_H */
|