debase-ruby_core_source 0.7.5 → 0.7.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/CONTRIBUTING.md +2 -1
  4. data/Rakefile +3 -2
  5. data/lib/debase/ruby_core_source/ruby-2.2.1/addr2line.h +21 -0
  6. data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/build_assert/build_assert.h +40 -0
  7. data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/check_type/check_type.h +63 -0
  8. data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/container_of/container_of.h +142 -0
  9. data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/list/list.h +635 -0
  10. data/lib/debase/ruby_core_source/ruby-2.2.1/ccan/str/str.h +16 -0
  11. data/lib/debase/ruby_core_source/ruby-2.2.1/constant.h +43 -0
  12. data/lib/debase/ruby_core_source/ruby-2.2.1/dln.h +51 -0
  13. data/lib/debase/ruby_core_source/ruby-2.2.1/eval_intern.h +275 -0
  14. data/lib/debase/ruby_core_source/ruby-2.2.1/gc.h +107 -0
  15. data/lib/debase/ruby_core_source/ruby-2.2.1/id.h +210 -0
  16. data/lib/debase/ruby_core_source/ruby-2.2.1/insns.inc +107 -0
  17. data/lib/debase/ruby_core_source/ruby-2.2.1/insns_info.inc +752 -0
  18. data/lib/debase/ruby_core_source/ruby-2.2.1/internal.h +1185 -0
  19. data/lib/debase/ruby_core_source/ruby-2.2.1/iseq.h +158 -0
  20. data/lib/debase/ruby_core_source/ruby-2.2.1/known_errors.inc +746 -0
  21. data/lib/debase/ruby_core_source/ruby-2.2.1/method.h +144 -0
  22. data/lib/debase/ruby_core_source/ruby-2.2.1/node.h +544 -0
  23. data/lib/debase/ruby_core_source/ruby-2.2.1/node_name.inc +212 -0
  24. data/lib/debase/ruby_core_source/ruby-2.2.1/opt_sc.inc +734 -0
  25. data/lib/debase/ruby_core_source/ruby-2.2.1/optinsn.inc +83 -0
  26. data/lib/debase/ruby_core_source/ruby-2.2.1/optunifs.inc +124 -0
  27. data/lib/debase/ruby_core_source/ruby-2.2.1/parse.h +203 -0
  28. data/lib/debase/ruby_core_source/ruby-2.2.1/probes_helper.h +67 -0
  29. data/lib/debase/ruby_core_source/ruby-2.2.1/regenc.h +234 -0
  30. data/lib/debase/ruby_core_source/ruby-2.2.1/regint.h +972 -0
  31. data/lib/debase/ruby_core_source/ruby-2.2.1/regparse.h +363 -0
  32. data/lib/debase/ruby_core_source/ruby-2.2.1/revision.h +1 -0
  33. data/lib/debase/ruby_core_source/ruby-2.2.1/ruby_atomic.h +170 -0
  34. data/lib/debase/ruby_core_source/ruby-2.2.1/siphash.h +48 -0
  35. data/lib/debase/ruby_core_source/ruby-2.2.1/symbol.h +87 -0
  36. data/lib/debase/ruby_core_source/ruby-2.2.1/thread_pthread.h +54 -0
  37. data/lib/debase/ruby_core_source/ruby-2.2.1/thread_win32.h +36 -0
  38. data/lib/debase/ruby_core_source/ruby-2.2.1/timev.h +42 -0
  39. data/lib/debase/ruby_core_source/ruby-2.2.1/transcode_data.h +123 -0
  40. data/lib/debase/ruby_core_source/ruby-2.2.1/version.h +52 -0
  41. data/lib/debase/ruby_core_source/ruby-2.2.1/vm.inc +3353 -0
  42. data/lib/debase/ruby_core_source/ruby-2.2.1/vm_core.h +1161 -0
  43. data/lib/debase/ruby_core_source/ruby-2.2.1/vm_debug.h +37 -0
  44. data/lib/debase/ruby_core_source/ruby-2.2.1/vm_exec.h +182 -0
  45. data/lib/debase/ruby_core_source/ruby-2.2.1/vm_insnhelper.h +233 -0
  46. data/lib/debase/ruby_core_source/ruby-2.2.1/vm_opts.h +56 -0
  47. data/lib/debase/ruby_core_source/ruby-2.2.1/vmtc.inc +105 -0
  48. data/lib/debase/ruby_core_source/version.rb +1 -1
  49. 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 */