[331] | 1 | #include <mruby.h>
|
---|
| 2 | #include <mruby/gc.h>
|
---|
| 3 | #include <mruby/hash.h>
|
---|
| 4 | #include <mruby/class.h>
|
---|
[270] | 5 |
|
---|
| 6 | struct os_count_struct {
|
---|
| 7 | mrb_int total;
|
---|
| 8 | mrb_int freed;
|
---|
| 9 | mrb_int counts[MRB_TT_MAXDEFINE+1];
|
---|
| 10 | };
|
---|
| 11 |
|
---|
[331] | 12 | static int
|
---|
[270] | 13 | os_count_object_type(mrb_state *mrb, struct RBasic *obj, void *data)
|
---|
| 14 | {
|
---|
| 15 | struct os_count_struct *obj_count;
|
---|
| 16 | obj_count = (struct os_count_struct*)data;
|
---|
| 17 |
|
---|
| 18 | obj_count->total++;
|
---|
| 19 |
|
---|
| 20 | if (mrb_object_dead_p(mrb, obj)) {
|
---|
| 21 | obj_count->freed++;
|
---|
| 22 | }
|
---|
| 23 | else {
|
---|
| 24 | obj_count->counts[obj->tt]++;
|
---|
| 25 | }
|
---|
[331] | 26 | return MRB_EACH_OBJ_OK;
|
---|
[270] | 27 | }
|
---|
| 28 |
|
---|
| 29 | /*
|
---|
| 30 | * call-seq:
|
---|
| 31 | * ObjectSpace.count_objects([result_hash]) -> hash
|
---|
| 32 | *
|
---|
| 33 | * Counts objects for each type.
|
---|
| 34 | *
|
---|
| 35 | * It returns a hash, such as:
|
---|
| 36 | * {
|
---|
| 37 | * :TOTAL=>10000,
|
---|
| 38 | * :FREE=>3011,
|
---|
| 39 | * :T_OBJECT=>6,
|
---|
| 40 | * :T_CLASS=>404,
|
---|
| 41 | * # ...
|
---|
| 42 | * }
|
---|
| 43 | *
|
---|
| 44 | * If the optional argument +result_hash+ is given,
|
---|
| 45 | * it is overwritten and returned. This is intended to avoid probe effect.
|
---|
| 46 | *
|
---|
| 47 | */
|
---|
| 48 |
|
---|
| 49 | static mrb_value
|
---|
| 50 | os_count_objects(mrb_state *mrb, mrb_value self)
|
---|
| 51 | {
|
---|
| 52 | struct os_count_struct obj_count = { 0 };
|
---|
[331] | 53 | mrb_int i;
|
---|
[270] | 54 | mrb_value hash;
|
---|
| 55 |
|
---|
| 56 | if (mrb_get_args(mrb, "|H", &hash) == 0) {
|
---|
| 57 | hash = mrb_hash_new(mrb);
|
---|
| 58 | }
|
---|
| 59 |
|
---|
| 60 | if (!mrb_test(mrb_hash_empty_p(mrb, hash))) {
|
---|
| 61 | mrb_hash_clear(mrb, hash);
|
---|
| 62 | }
|
---|
| 63 |
|
---|
| 64 | mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
|
---|
| 65 |
|
---|
| 66 | mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
|
---|
| 67 | mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
|
---|
| 68 |
|
---|
| 69 | for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
|
---|
| 70 | mrb_value type;
|
---|
| 71 | switch (i) {
|
---|
| 72 | #define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(mrb_intern_lit(mrb, #t)); break;
|
---|
| 73 | COUNT_TYPE(T_FALSE);
|
---|
| 74 | COUNT_TYPE(T_FREE);
|
---|
| 75 | COUNT_TYPE(T_TRUE);
|
---|
| 76 | COUNT_TYPE(T_FIXNUM);
|
---|
| 77 | COUNT_TYPE(T_SYMBOL);
|
---|
| 78 | COUNT_TYPE(T_UNDEF);
|
---|
| 79 | COUNT_TYPE(T_FLOAT);
|
---|
| 80 | COUNT_TYPE(T_CPTR);
|
---|
| 81 | COUNT_TYPE(T_OBJECT);
|
---|
| 82 | COUNT_TYPE(T_CLASS);
|
---|
| 83 | COUNT_TYPE(T_MODULE);
|
---|
| 84 | COUNT_TYPE(T_ICLASS);
|
---|
| 85 | COUNT_TYPE(T_SCLASS);
|
---|
| 86 | COUNT_TYPE(T_PROC);
|
---|
| 87 | COUNT_TYPE(T_ARRAY);
|
---|
| 88 | COUNT_TYPE(T_HASH);
|
---|
| 89 | COUNT_TYPE(T_STRING);
|
---|
| 90 | COUNT_TYPE(T_RANGE);
|
---|
| 91 | COUNT_TYPE(T_EXCEPTION);
|
---|
| 92 | COUNT_TYPE(T_FILE);
|
---|
| 93 | COUNT_TYPE(T_ENV);
|
---|
| 94 | COUNT_TYPE(T_DATA);
|
---|
| 95 | COUNT_TYPE(T_FIBER);
|
---|
| 96 | #undef COUNT_TYPE
|
---|
| 97 | default:
|
---|
| 98 | type = mrb_fixnum_value(i); break;
|
---|
| 99 | }
|
---|
| 100 | if (obj_count.counts[i])
|
---|
| 101 | mrb_hash_set(mrb, hash, type, mrb_fixnum_value(obj_count.counts[i]));
|
---|
| 102 | }
|
---|
| 103 |
|
---|
| 104 | return hash;
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 107 | struct os_each_object_data {
|
---|
| 108 | mrb_value block;
|
---|
| 109 | struct RClass *target_module;
|
---|
| 110 | mrb_int count;
|
---|
| 111 | };
|
---|
| 112 |
|
---|
[331] | 113 | static int
|
---|
[270] | 114 | os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
|
---|
| 115 | {
|
---|
| 116 | struct os_each_object_data *d = (struct os_each_object_data*)ud;
|
---|
| 117 |
|
---|
| 118 | /* filter dead objects */
|
---|
| 119 | if (mrb_object_dead_p(mrb, obj)) {
|
---|
[331] | 120 | return MRB_EACH_OBJ_OK;
|
---|
[270] | 121 | }
|
---|
| 122 |
|
---|
| 123 | /* filter internal objects */
|
---|
| 124 | switch (obj->tt) {
|
---|
| 125 | case MRB_TT_ENV:
|
---|
| 126 | case MRB_TT_ICLASS:
|
---|
[331] | 127 | return MRB_EACH_OBJ_OK;
|
---|
[270] | 128 | default:
|
---|
| 129 | break;
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | /* filter half baked (or internal) objects */
|
---|
[331] | 133 | if (!obj->c) return MRB_EACH_OBJ_OK;
|
---|
[270] | 134 |
|
---|
| 135 | /* filter class kind if target module defined */
|
---|
| 136 | if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
|
---|
[331] | 137 | return MRB_EACH_OBJ_OK;
|
---|
[270] | 138 | }
|
---|
| 139 |
|
---|
| 140 | mrb_yield(mrb, d->block, mrb_obj_value(obj));
|
---|
| 141 | ++d->count;
|
---|
[331] | 142 | return MRB_EACH_OBJ_OK;
|
---|
[270] | 143 | }
|
---|
| 144 |
|
---|
| 145 | /*
|
---|
| 146 | * call-seq:
|
---|
| 147 | * ObjectSpace.each_object([module]) {|obj| ... } -> fixnum
|
---|
| 148 | *
|
---|
| 149 | * Calls the block once for each object in this Ruby process.
|
---|
| 150 | * Returns the number of objects found.
|
---|
| 151 | * If the optional argument +module+ is given,
|
---|
| 152 | * calls the block for only those classes or modules
|
---|
| 153 | * that match (or are a subclass of) +module+.
|
---|
| 154 | *
|
---|
| 155 | * If no block is given, ArgumentError is raised.
|
---|
| 156 | *
|
---|
| 157 | */
|
---|
| 158 |
|
---|
| 159 | static mrb_value
|
---|
| 160 | os_each_object(mrb_state *mrb, mrb_value self)
|
---|
| 161 | {
|
---|
| 162 | mrb_value cls = mrb_nil_value();
|
---|
| 163 | struct os_each_object_data d;
|
---|
| 164 | mrb_get_args(mrb, "&|C", &d.block, &cls);
|
---|
| 165 |
|
---|
| 166 | if (mrb_nil_p(d.block)) {
|
---|
| 167 | mrb_raise(mrb, E_ARGUMENT_ERROR, "Expected block in ObjectSpace.each_object.");
|
---|
| 168 | }
|
---|
| 169 |
|
---|
| 170 | d.target_module = mrb_nil_p(cls) ? NULL : mrb_class_ptr(cls);
|
---|
| 171 | d.count = 0;
|
---|
| 172 | mrb_objspace_each_objects(mrb, os_each_object_cb, &d);
|
---|
| 173 | return mrb_fixnum_value(d.count);
|
---|
| 174 | }
|
---|
| 175 |
|
---|
| 176 | void
|
---|
| 177 | mrb_mruby_objectspace_gem_init(mrb_state *mrb)
|
---|
| 178 | {
|
---|
| 179 | struct RClass *os = mrb_define_module(mrb, "ObjectSpace");
|
---|
| 180 | mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_OPT(1));
|
---|
| 181 | mrb_define_class_method(mrb, os, "each_object", os_each_object, MRB_ARGS_OPT(1));
|
---|
| 182 | }
|
---|
| 183 |
|
---|
| 184 | void
|
---|
| 185 | mrb_mruby_objectspace_gem_final(mrb_state *mrb)
|
---|
| 186 | {
|
---|
| 187 | }
|
---|