static VALUE
count_objects_size(int argc, VALUE *argv, VALUE os)
{
size_t counts[T_MASK+1];
size_t total = 0;
enum ruby_value_type i;
VALUE hash = setup_hash(argc, argv);
for (i = 0; i <= T_MASK; i++) {
counts[i] = 0;
}
rb_objspace_each_objects(cos_i, &counts[0]);
if (hash == Qnil) {
hash = rb_hash_new();
}
else if (!RHASH_EMPTY_P(hash)) {
st_foreach(RHASH_TBL(hash), set_zero_i, hash);
}
for (i = 0; i <= T_MASK; i++) {
if (counts[i]) {
VALUE type = type2sym(i);
total += counts[i];
rb_hash_aset(hash, type, SIZET2NUM(counts[i]));
}
}
rb_hash_aset(hash, ID2SYM(rb_intern("TOTAL")), SIZET2NUM(total));
return hash;
}
static VALUE
stackprof_results(VALUE self)
{
VALUE results, frames;
if (!_stackprof.frames || _stackprof.running)
return Qnil;
results = rb_hash_new();
rb_hash_aset(results, sym_version, DBL2NUM(1.1));
rb_hash_aset(results, sym_mode, _stackprof.mode);
rb_hash_aset(results, sym_interval, _stackprof.interval);
rb_hash_aset(results, sym_samples, SIZET2NUM(_stackprof.overall_samples));
rb_hash_aset(results, sym_gc_samples, SIZET2NUM(_stackprof.during_gc));
rb_hash_aset(results, sym_missed_samples, SIZET2NUM(_stackprof.overall_signals - _stackprof.overall_samples));
frames = rb_hash_new();
rb_hash_aset(results, sym_frames, frames);
st_foreach(_stackprof.frames, frame_i, (st_data_t)frames);
st_free_table(_stackprof.frames);
_stackprof.frames = NULL;
return results;
}
static VALUE symbol_new(bfd * abfd, asymbol *s, char is_dynamic) {
symbol_info info;
VALUE class, instance;
VALUE argv[1] = { Qnil };
class = rb_class_new(clsSymbol);
instance = Data_Wrap_Struct(class, NULL, NULL, s);
rb_obj_call_init(instance, 0, argv);
bfd_symbol_info(s, &info);
/* set instance variables */
rb_iv_set(instance, IVAR(SYM_ATTR_NAME), rb_str_new_cstr(info.name) );
rb_iv_set(instance, IVAR(SYM_ATTR_TYPE), INT2NUM((int) info.type) );
rb_iv_set(instance, IVAR(SYM_ATTR_VALUE), SIZET2NUM(info.value) );
rb_iv_set(instance, IVAR(SYM_ATTR_FLAGS), INT2NUM(s->flags) );
rb_iv_set(instance, IVAR(SYM_ATTR_BIND),
rb_str_new_cstr( (is_dynamic ? SYM_BIND_DYNAMIC :
SYM_BIND_STATIC) ) );
if ( s->section ) {
rb_iv_set(instance, IVAR(SYM_ATTR_SECTION),
rb_str_new_cstr(s->section->name));
}
return instance;
}
static VALUE rb_smbfile_pos(VALUE self)
{
RB_SMBFILE_DATA_FROM_OBJ(self, data);
RB_SMBFILE_DATA_CLOSED(data);
return SIZET2NUM(data->pos);
}
static void
rb_block_applier(void *data, size_t ii)
{
assert(data != NULL);
rb_vm_block_t *block = rb_vm_uncache_or_dup_block((rb_vm_block_t *)data);
rb_block_arg_dispatcher(block, SIZET2NUM(ii));
}
static VALUE
rb_gl_buffer_addr(VALUE self) {
struct buffer *buf;
TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
return SIZET2NUM((size_t)buf->ptr);
}
static VALUE
oobgc_stat(VALUE self, VALUE key)
{
if (!_oobgc.installed)
return Qnil;
if (key == sym_count)
return SIZET2NUM(_oobgc.stat.major + _oobgc.stat.minor + _oobgc.stat.sweep);
else if (key == sym_major_count)
return SIZET2NUM(_oobgc.stat.major);
else if (key == sym_minor_count)
return SIZET2NUM(_oobgc.stat.minor);
else if (key == sym_sweep_count)
return SIZET2NUM(_oobgc.stat.sweep);
else
return Qnil;
}
static int
frame_i(st_data_t key, st_data_t val, st_data_t arg)
{
VALUE frame = (VALUE)key;
frame_data_t *frame_data = (frame_data_t *)val;
VALUE results = (VALUE)arg;
VALUE details = rb_hash_new();
VALUE name, file, edges, lines;
VALUE line;
rb_hash_aset(results, rb_obj_id(frame), details);
name = rb_profile_frame_full_label(frame);
rb_hash_aset(details, sym_name, name);
file = rb_profile_frame_absolute_path(frame);
if (NIL_P(file))
file = rb_profile_frame_path(frame);
rb_hash_aset(details, sym_file, file);
if ((line = rb_profile_frame_first_lineno(frame)) != INT2FIX(0))
rb_hash_aset(details, sym_line, line);
rb_hash_aset(details, sym_total_samples, SIZET2NUM(frame_data->total_samples));
rb_hash_aset(details, sym_samples, SIZET2NUM(frame_data->caller_samples));
if (frame_data->edges) {
edges = rb_hash_new();
rb_hash_aset(details, sym_edges, edges);
st_foreach(frame_data->edges, frame_edges_i, (st_data_t)edges);
st_free_table(frame_data->edges);
frame_data->edges = NULL;
}
if (frame_data->lines) {
lines = rb_hash_new();
rb_hash_aset(details, sym_lines, lines);
st_foreach(frame_data->lines, frame_lines_i, (st_data_t)lines);
st_free_table(frame_data->lines);
frame_data->lines = NULL;
}
xfree(frame_data);
return ST_DELETE;
}
/*
* call-seq:
* rd.dup -> rd_copy
*
* Duplicates and snapshots the current state of a Raindrops object.
*/
static VALUE init_copy(VALUE dest, VALUE source)
{
struct raindrops *dst = DATA_PTR(dest);
struct raindrops *src = get(source);
init(dest, SIZET2NUM(src->size));
memcpy(dst->drops, src->drops, raindrop_size * src->size);
return dest;
}
VALUE rb_digest(int argc, VALUE *argv, VALUE self) {
VALUE string, options, method = Qnil;
rb_scan_args(argc, argv, "11", &string, &options);
if (TYPE(options) == T_HASH)
method = rb_hash_aref(options, sMethod);
int algo = NIL_P(method) ? 0 : FIX2INT(method);
return SIZET2NUM(algo == 1 ? djhash(CSTRING(string)) : sdbm(CSTRING(string)));
}
static VALUE Buffer_write(VALUE self, VALUE string_or_buffer)
{
BUFFER(self, b);
VALUE string = string_or_buffer; // TODO optimize if string_or_buffer is a Buffer
StringValue(string);
size_t length = msgpack_buffer_append_string(b, string);
return SIZET2NUM(length);
}
static VALUE
memsize_of_all_m(int argc, VALUE *argv, VALUE self)
{
struct total_data data = {0, 0};
if (argc > 0) {
rb_scan_args(argc, argv, "01", &data.klass);
}
rb_objspace_each_objects(total_i, &data);
return SIZET2NUM(data.total);
}
static VALUE section_new(bfd * abfd, asection *s) {
VALUE class, instance;
VALUE argv[1] = { Qnil };
class = rb_class_new(clsSection);
instance = Data_Wrap_Struct(class, NULL, NULL, s);
rb_obj_call_init(instance, 0, argv);
/* set instance variables */
rb_iv_set(instance, IVAR(SEC_ATTR_ID), INT2NUM(s->id) );
rb_iv_set(instance, IVAR(SEC_ATTR_NAME), rb_str_new_cstr(s->name) );
rb_iv_set(instance, IVAR(SEC_ATTR_INDEX), INT2NUM(s->index) );
rb_iv_set(instance, IVAR(SEC_ATTR_FLAGS), INT2NUM(s->flags) );
rb_iv_set(instance, IVAR(SEC_ATTR_VMA), SIZET2NUM(s->vma) );
rb_iv_set(instance, IVAR(SEC_ATTR_LMA), SIZET2NUM(s->lma) );
rb_iv_set(instance, IVAR(SEC_ATTR_SIZE),
SIZET2NUM(bfd_section_size(abfd, s)) );
rb_iv_set(instance, IVAR(SEC_ATTR_ALIGN), INT2NUM(s->alignment_power) );
rb_iv_set(instance, IVAR(SEC_ATTR_FPOS), SIZET2NUM(s->filepos) );
rb_iv_set(instance, IVAR(SEC_ATTR_CONTENTS), Qnil);
return instance;
}
static VALUE
count_symbols(int argc, VALUE *argv, VALUE os)
{
struct dynamic_symbol_counts dynamic_counts = {0, 0};
VALUE hash = setup_hash(argc, argv);
size_t immortal_symbols = rb_sym_immortal_count();
rb_objspace_each_objects(cs_i, &dynamic_counts);
if (hash == Qnil) {
hash = rb_hash_new();
}
else if (!RHASH_EMPTY_P(hash)) {
st_foreach(RHASH_TBL(hash), set_zero_i, hash);
}
rb_hash_aset(hash, ID2SYM(rb_intern("mortal_dynamic_symbol")), SIZET2NUM(dynamic_counts.mortal));
rb_hash_aset(hash, ID2SYM(rb_intern("immortal_dynamic_symbol")), SIZET2NUM(dynamic_counts.immortal));
rb_hash_aset(hash, ID2SYM(rb_intern("immortal_static_symbol")), SIZET2NUM(immortal_symbols - dynamic_counts.immortal));
rb_hash_aset(hash, ID2SYM(rb_intern("immortal_symbol")), SIZET2NUM(immortal_symbols));
return hash;
}
VALUE cbasic_hash(VALUE self) {
basic_struct *this;
Data_Get_Struct(self, basic_struct, this);
// All ruby objects return FIXNUM when `hash` method is called.
// Though this function returns BIGNUM it won't be a problem, since
// we need proper comparison only among objects in SymEngine.
// The objects that should have the same hash will always match
// and when comparing to the FIXNUM from hash of other ruby objects,
// it will return false as it is supposed to.
// However, an alternate implementation is given below
// long lhash = basic_hash(this) % FIX2LONG(FIXNUM_MAX);
// return LONG2FIX(lhash);
return SIZET2NUM(basic_hash(this));
}
/*
* call-seq:
* Settings[option] -> value
*
* Gets the value of a libgit2 library option.
*/
static VALUE rb_git_get_option(VALUE self, VALUE option)
{
const char *opt;
Check_Type(option, T_STRING);
opt = StringValueCStr(option);
if (strcmp(opt, "mwindow_size") == 0) {
size_t val;
git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &val);
return SIZET2NUM(val);
}
else if (strcmp(opt, "mwindow_mapped_limit") == 0) {
size_t val;
git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &val);
return SIZET2NUM(val);
}
else {
rb_raise(rb_eArgError, "Unknown option specified");
}
}
// read from buffer and return a ruby string
// params: dest, dest_start=0, src_start=0, len=self.length
// return: bytes copied
VALUE ruv_buffer_copy(int argc, VALUE* argv, VALUE rb_src) {
VALUE rb_dest, rb_dest_start, rb_src_start, rb_length;
size_t dest_start, src_start, length;
ruv_buffer_t *src, *dest;
rb_scan_args(argc, argv, "13", &rb_dest, &rb_dest_start, &rb_src_start, &rb_length);
if(!rb_obj_is_kind_of(rb_dest, rb_obj_class(rb_src))) {
rb_raise(rb_eArgError, "Dest is not a buffer");
}
Data_Get_Struct(rb_src, ruv_buffer_t, src);
Data_Get_Struct(rb_dest, ruv_buffer_t, dest);
if(!NIL_P(rb_dest_start)) {
Check_Type(rb_dest_start, T_FIXNUM);
dest_start = NUM2SIZET(rb_dest_start);
} else {
dest_start = 0;
}
if(dest_start >= dest->length) {
rb_raise(rb_eArgError, "dest_start is out of bounds.");
}
if(!NIL_P(rb_src_start)) {
Check_Type(rb_src_start, T_FIXNUM);
src_start = NUM2SIZET(rb_src_start);
} else {
src_start = 0;
}
if(src_start >= src->length) {
rb_raise(rb_eArgError, "src_start is out of bounds.");
}
if(!NIL_P(rb_length)) {
Check_Type(rb_length, T_FIXNUM);
length = NUM2SIZET(rb_length);
} else {
length = src->length - src_start;
}
// make sure it's not out of bound
length = MIN(length, src->length - src_start);
length = MIN(length, dest->length - dest_start);
memcpy(dest->data + dest_start, src->data + src_start, length);
return SIZET2NUM(length);
}
static VALUE
count_objects_size(int argc, VALUE *argv, VALUE os)
{
size_t counts[T_MASK+1];
size_t total = 0;
enum ruby_value_type i;
VALUE hash;
if (rb_scan_args(argc, argv, "01", &hash) == 1) {
if (!RB_TYPE_P(hash, T_HASH))
rb_raise(rb_eTypeError, "non-hash given");
}
for (i = 0; i <= T_MASK; i++) {
counts[i] = 0;
}
rb_objspace_each_objects(cos_i, &counts[0]);
if (hash == Qnil) {
hash = rb_hash_new();
}
else if (!RHASH_EMPTY_P(hash)) {
st_foreach(RHASH_TBL(hash), set_zero_i, hash);
}
for (i = 0; i <= T_MASK; i++) {
if (counts[i]) {
VALUE type = type2sym(i);
total += counts[i];
rb_hash_aset(hash, type, SIZET2NUM(counts[i]));
}
}
rb_hash_aset(hash, ID2SYM(rb_intern("TOTAL")), SIZET2NUM(total));
return hash;
}
static double
get_double_rshift(VALUE x, size_t *pnumbits)
{
size_t numbits;
if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
numbits -= DBL_MANT_DIG;
x = rb_big_rshift(x, SIZET2NUM(numbits));
}
else {
numbits = 0;
}
*pnumbits = numbits;
return Get_Double(x);
}
// read from buffer and return a ruby string
// params: value, start=0, end=self.length
// return: bytes copied
VALUE ruv_buffer_fill(int argc, VALUE* argv, VALUE rb_buffer) {
VALUE rb_value, rb_start, rb_length;
size_t start, length;
ruv_buffer_t *buffer;
int value;
Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer);
rb_scan_args(argc, argv, "12", &rb_value, &rb_start, &rb_length);
value = NUM2INT(rb_value);
if(value > 255 || value < 0) {
rb_raise(rb_eArgError, "value must be between 0 to 255");
}
if(!NIL_P(rb_start)) {
Check_Type(rb_start, T_FIXNUM);
start = NUM2SIZET(rb_start);
} else {
start = 0;
}
if(start >= buffer->length) {
rb_raise(rb_eArgError, "start is out of bounds.");
}
if(!NIL_P(rb_length)) {
Check_Type(rb_length, T_FIXNUM);
length = NUM2SIZET(length);
} else {
length = buffer->length - start;
}
// make sure it's not out of bound
length = MIN(length, buffer->length - start);
memset(buffer->data + start, value, length);
return SIZET2NUM(length);
}
static VALUE
math_log10(VALUE obj, VALUE x)
{
double d;
size_t numbits;
if (RB_BIGNUM_TYPE_P(x) && BIGNUM_POSITIVE_P(x) &&
DBL_MAX_EXP <= (numbits = rb_absint_numwords(x, 1, NULL))) {
numbits -= DBL_MANT_DIG;
x = rb_big_rshift(x, SIZET2NUM(numbits));
}
else {
numbits = 0;
}
d = Get_Double(x);
/* check for domain error */
if (d < 0.0) domain_error("log10");
/* check for pole error */
if (d == 0.0) return DBL2NUM(-INFINITY);
return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */
}
/*
* call-seq:
* Krypt::PEM.decode(data) { |der, name, i| block } -> Array
*
* +data+ can be either a PEM-encoded String, an IO-like object that features
* a +read+ method or any arbitrary object that has a +to_pem+ method returning
* either a String or an IO-like object.
*
* Returns an Array that contains the DER-encoded results in the order they
* were decoded. PEM data can potentially consist of multiple elements, a
* common example being 'trusted certificate bundles' that contain a set of
* to-be-trusted certificates.
*
* If additionally a block is given, +block+ is called for each element that is
* decoded, where +der+ contains the decoded element, +name+ the identifier of
* the current element (e.g. 'CERTIFICATE') and +i+ the index of the current
* element starting with 0.
*
* === Example: Decoding a simple certificate file
*
* File.open("certificate.pem", "rb") do |f|
* cert = Krypt::PEM.decode(f)[0]
* # process the certificate
* end
*
* === Example: Decoding multiple elements contained in one file
*
* File.open("trusted-certs.pem", "rb") do |f|
* Krypt::PEM.decode(f) do |der, name, i|
* puts "Element #{i}: #{name}"
* File.open("cert-#{i}.der", "wb") do |g|
* g.print der
* end
* end
* end
*/
static VALUE
krypt_pem_decode(VALUE self, VALUE pem)
{
VALUE ary, der;
size_t i = 0;
int result;
binyo_instream *in = krypt_instream_new_pem(krypt_instream_new_value_pem(pem));
ary = rb_ary_new();
while ((result = int_consume_stream(in, &der)) == KRYPT_OK) {
if (NIL_P(der))
break;
rb_ary_push(ary, der);
if(rb_block_given_p()) {
uint8_t *name;
size_t len;
VALUE vname;
if (krypt_pem_get_last_name(in, &name, &len) == BINYO_ERR) goto error;
vname = rb_str_new((const char *) name, len);
xfree(name);
rb_yield_values(3, der, vname, SIZET2NUM(i++));
}
krypt_pem_continue_stream(in);
}
if (result == KRYPT_ERR) goto error;
binyo_instream_free(in);
return ary;
error:
binyo_instream_free(in);
krypt_error_raise(eKryptPEMError, "Error while decoding PEM data");
return Qnil;
}
static VALUE
count_objects(VALUE os, SEL sel, int argc, VALUE *argv)
{
/* TODO implement me! */
return rb_hash_new();
#if 0
rb_objspace_t *objspace = &rb_objspace;
size_t counts[T_MASK+1];
size_t freed = 0;
size_t total = 0;
size_t i;
VALUE hash;
if (rb_scan_args(argc, argv, "01", &hash) == 1) {
if (TYPE(hash) != T_HASH)
rb_raise(rb_eTypeError, "non-hash given");
}
for (i = 0; i <= T_MASK; i++) {
counts[i] = 0;
}
for (i = 0; i < heaps_used; i++) {
RVALUE *p, *pend;
p = heaps[i].slot; pend = p + heaps[i].limit;
for (;p < pend; p++) {
if (p->as.basic.flags) {
counts[BUILTIN_TYPE(p)]++;
}
else {
freed++;
}
}
total += heaps[i].limit;
}
if (hash == Qnil)
hash = rb_hash_new();
rb_hash_aset(hash, ID2SYM(rb_intern("TOTAL")), SIZET2NUM(total));
rb_hash_aset(hash, ID2SYM(rb_intern("FREE")), SIZET2NUM(freed));
for (i = 0; i <= T_MASK; i++) {
VALUE type;
switch (i) {
#define COUNT_TYPE(t) case t: type = ID2SYM(rb_intern(#t)); break;
COUNT_TYPE(T_NONE);
COUNT_TYPE(T_OBJECT);
COUNT_TYPE(T_CLASS);
COUNT_TYPE(T_MODULE);
COUNT_TYPE(T_FLOAT);
COUNT_TYPE(T_STRING);
COUNT_TYPE(T_REGEXP);
COUNT_TYPE(T_ARRAY);
COUNT_TYPE(T_HASH);
COUNT_TYPE(T_STRUCT);
COUNT_TYPE(T_BIGNUM);
COUNT_TYPE(T_FILE);
COUNT_TYPE(T_DATA);
COUNT_TYPE(T_MATCH);
COUNT_TYPE(T_COMPLEX);
COUNT_TYPE(T_RATIONAL);
COUNT_TYPE(T_NIL);
COUNT_TYPE(T_TRUE);
COUNT_TYPE(T_FALSE);
COUNT_TYPE(T_SYMBOL);
COUNT_TYPE(T_FIXNUM);
COUNT_TYPE(T_VALUES);
COUNT_TYPE(T_UNDEF);
COUNT_TYPE(T_NODE);
COUNT_TYPE(T_ICLASS);
#undef COUNT_TYPE
default: type = INT2NUM(i); break;
}
if (counts[i])
rb_hash_aset(hash, type, SIZET2NUM(counts[i]));
}
return hash;
#endif
}
static VALUE Packer_size(VALUE self)
{
PACKER(self, pk);
size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
return SIZET2NUM(size);
}
VALUE ruv_buffer_write(int argc, VALUE* argv, VALUE rb_buffer) {
VALUE rb_str, rb_offset, rb_length, rb_extern_enc, rb_cBuffer;
size_t offset, length, max_length, char_count;
ruv_buffer_t *buffer;
rb_encoding *rb_extern_encoding;
Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer);
rb_scan_args(argc, argv, "13", &rb_str, &rb_offset, &rb_length, &rb_extern_enc);
StringValue(rb_str);
// encoding: use specified external encoding if provided
// otherwise use Encoding.default_external as default
if(!NIL_P(rb_extern_enc)) {
rb_extern_encoding = rb_enc_get(rb_extern_enc);
} else {
rb_extern_encoding = rb_default_external_encoding();
}
// convert to external encoding
rb_str = rb_str_export_to_enc(rb_str, rb_extern_encoding);
// offset: either specified in params or 0
if(!NIL_P(rb_offset)) {
Check_Type(rb_offset, T_FIXNUM);
offset = NUM2SIZET(rb_offset);
if(offset >= buffer->length) {
rb_raise(rb_eArgError, "Overflow! offset is larger than buffer size.");
}
} else {
offset = 0;
}
// max length: the smaller of the max available space or the whole ruby string
max_length = MIN(buffer->length - offset, (size_t)RSTRING_LEN(rb_str));
// length: number of bytes to write. (include half chars)
if(!NIL_P(rb_length)) {
Check_Type(rb_length, T_FIXNUM);
length = NUM2SIZET(rb_length);
} else {
length = max_length;
}
// If we are not writing the whole string into the buffer,
// re-adjust length so we don't write half a character (uft8, etc)
// 1). get char count from calculated byte length
// 2). get byte length back from char count
// This way only whole char is written to buffer
if(length != (size_t)RSTRING_LEN(rb_str)) {
char_count = rb_str_sublen(rb_str, length);
length = rb_str_offset(rb_str, char_count);
}
memcpy(buffer->data + offset, RSTRING_PTR(rb_str), length);
// set instance variable so we know how much characters are written
rb_cBuffer = rb_obj_class(rb_buffer);
rb_iv_set(rb_cBuffer, RUV_BUFFER_CHAR_WRITTEN_SYM, SIZET2NUM(char_count));
return SIZET2NUM(length);
}
VALUE ruv_buffer_length(VALUE rb_buffer) {
ruv_buffer_t *buffer;
Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer);
return SIZET2NUM(buffer->length);
}
static VALUE
stackprof_results(int argc, VALUE *argv, VALUE self)
{
VALUE results, frames;
if (!_stackprof.frames || _stackprof.running)
return Qnil;
results = rb_hash_new();
rb_hash_aset(results, sym_version, DBL2NUM(1.1));
rb_hash_aset(results, sym_mode, _stackprof.mode);
rb_hash_aset(results, sym_interval, _stackprof.interval);
rb_hash_aset(results, sym_samples, SIZET2NUM(_stackprof.overall_samples));
rb_hash_aset(results, sym_gc_samples, SIZET2NUM(_stackprof.during_gc));
rb_hash_aset(results, sym_missed_samples, SIZET2NUM(_stackprof.overall_signals - _stackprof.overall_samples));
frames = rb_hash_new();
rb_hash_aset(results, sym_frames, frames);
st_foreach(_stackprof.frames, frame_i, (st_data_t)frames);
st_free_table(_stackprof.frames);
_stackprof.frames = NULL;
if (_stackprof.raw && _stackprof.raw_samples_len) {
size_t len, n, o;
VALUE raw_samples = rb_ary_new_capa(_stackprof.raw_samples_len);
for (n = 0; n < _stackprof.raw_samples_len; n++) {
len = (size_t)_stackprof.raw_samples[n];
rb_ary_push(raw_samples, SIZET2NUM(len));
for (o = 0, n++; o < len; n++, o++)
rb_ary_push(raw_samples, rb_obj_id(_stackprof.raw_samples[n]));
rb_ary_push(raw_samples, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
}
free(_stackprof.raw_samples);
_stackprof.raw_samples = NULL;
_stackprof.raw_samples_len = 0;
_stackprof.raw_samples_capa = 0;
_stackprof.raw_sample_index = 0;
_stackprof.raw = 0;
rb_hash_aset(results, sym_raw, raw_samples);
}
if (argc == 1)
_stackprof.out = argv[0];
if (RTEST(_stackprof.out)) {
VALUE file;
if (RB_TYPE_P(_stackprof.out, T_STRING)) {
file = rb_file_open_str(_stackprof.out, "w");
} else {
file = rb_io_check_io(_stackprof.out);
}
rb_marshal_dump(results, file);
rb_io_flush(file);
_stackprof.out = Qnil;
return file;
} else {
return results;
}
}
static VALUE
count_nodes(int argc, VALUE *argv, VALUE os)
{
size_t nodes[NODE_LAST+1];
size_t i;
VALUE hash;
if (rb_scan_args(argc, argv, "01", &hash) == 1) {
if (TYPE(hash) != T_HASH)
rb_raise(rb_eTypeError, "non-hash given");
}
for (i = 0; i <= NODE_LAST; i++) {
nodes[i] = 0;
}
rb_objspace_each_objects(cn_i, &nodes[0]);
if (hash == Qnil) {
hash = rb_hash_new();
}
else if (!RHASH_EMPTY_P(hash)) {
st_foreach(RHASH_TBL(hash), set_zero_i, hash);
}
for (i=0; i<NODE_LAST; i++) {
if (nodes[i] != 0) {
VALUE node;
switch (i) {
#define COUNT_NODE(n) case n: node = ID2SYM(rb_intern(#n)); break;
COUNT_NODE(NODE_SCOPE);
COUNT_NODE(NODE_BLOCK);
COUNT_NODE(NODE_IF);
COUNT_NODE(NODE_CASE);
COUNT_NODE(NODE_WHEN);
COUNT_NODE(NODE_OPT_N);
COUNT_NODE(NODE_WHILE);
COUNT_NODE(NODE_UNTIL);
COUNT_NODE(NODE_ITER);
COUNT_NODE(NODE_FOR);
COUNT_NODE(NODE_BREAK);
COUNT_NODE(NODE_NEXT);
COUNT_NODE(NODE_REDO);
COUNT_NODE(NODE_RETRY);
COUNT_NODE(NODE_BEGIN);
COUNT_NODE(NODE_RESCUE);
COUNT_NODE(NODE_RESBODY);
COUNT_NODE(NODE_ENSURE);
COUNT_NODE(NODE_AND);
COUNT_NODE(NODE_OR);
COUNT_NODE(NODE_MASGN);
COUNT_NODE(NODE_LASGN);
COUNT_NODE(NODE_DASGN);
COUNT_NODE(NODE_DASGN_CURR);
COUNT_NODE(NODE_GASGN);
COUNT_NODE(NODE_IASGN);
COUNT_NODE(NODE_IASGN2);
COUNT_NODE(NODE_CDECL);
COUNT_NODE(NODE_CVASGN);
COUNT_NODE(NODE_CVDECL);
COUNT_NODE(NODE_OP_ASGN1);
COUNT_NODE(NODE_OP_ASGN2);
COUNT_NODE(NODE_OP_ASGN_AND);
COUNT_NODE(NODE_OP_ASGN_OR);
COUNT_NODE(NODE_CALL);
COUNT_NODE(NODE_FCALL);
COUNT_NODE(NODE_VCALL);
COUNT_NODE(NODE_SUPER);
COUNT_NODE(NODE_ZSUPER);
COUNT_NODE(NODE_ARRAY);
COUNT_NODE(NODE_ZARRAY);
COUNT_NODE(NODE_VALUES);
COUNT_NODE(NODE_HASH);
COUNT_NODE(NODE_RETURN);
COUNT_NODE(NODE_YIELD);
COUNT_NODE(NODE_LVAR);
COUNT_NODE(NODE_DVAR);
COUNT_NODE(NODE_GVAR);
COUNT_NODE(NODE_IVAR);
COUNT_NODE(NODE_CONST);
COUNT_NODE(NODE_CVAR);
COUNT_NODE(NODE_NTH_REF);
COUNT_NODE(NODE_BACK_REF);
COUNT_NODE(NODE_MATCH);
COUNT_NODE(NODE_MATCH2);
COUNT_NODE(NODE_MATCH3);
COUNT_NODE(NODE_LIT);
COUNT_NODE(NODE_STR);
COUNT_NODE(NODE_DSTR);
COUNT_NODE(NODE_XSTR);
COUNT_NODE(NODE_DXSTR);
COUNT_NODE(NODE_EVSTR);
COUNT_NODE(NODE_DREGX);
COUNT_NODE(NODE_DREGX_ONCE);
COUNT_NODE(NODE_ARGS);
COUNT_NODE(NODE_ARGS_AUX);
COUNT_NODE(NODE_OPT_ARG);
COUNT_NODE(NODE_POSTARG);
COUNT_NODE(NODE_ARGSCAT);
COUNT_NODE(NODE_ARGSPUSH);
COUNT_NODE(NODE_SPLAT);
COUNT_NODE(NODE_TO_ARY);
COUNT_NODE(NODE_BLOCK_ARG);
COUNT_NODE(NODE_BLOCK_PASS);
COUNT_NODE(NODE_DEFN);
COUNT_NODE(NODE_DEFS);
COUNT_NODE(NODE_ALIAS);
COUNT_NODE(NODE_VALIAS);
COUNT_NODE(NODE_UNDEF);
COUNT_NODE(NODE_CLASS);
COUNT_NODE(NODE_MODULE);
COUNT_NODE(NODE_SCLASS);
COUNT_NODE(NODE_COLON2);
COUNT_NODE(NODE_COLON3);
COUNT_NODE(NODE_DOT2);
COUNT_NODE(NODE_DOT3);
COUNT_NODE(NODE_FLIP2);
COUNT_NODE(NODE_FLIP3);
COUNT_NODE(NODE_SELF);
COUNT_NODE(NODE_NIL);
COUNT_NODE(NODE_TRUE);
COUNT_NODE(NODE_FALSE);
COUNT_NODE(NODE_ERRINFO);
COUNT_NODE(NODE_DEFINED);
COUNT_NODE(NODE_POSTEXE);
COUNT_NODE(NODE_ALLOCA);
COUNT_NODE(NODE_BMETHOD);
COUNT_NODE(NODE_MEMO);
COUNT_NODE(NODE_IFUNC);
COUNT_NODE(NODE_DSYM);
COUNT_NODE(NODE_ATTRASGN);
COUNT_NODE(NODE_PRELUDE);
COUNT_NODE(NODE_LAMBDA);
COUNT_NODE(NODE_OPTBLOCK);
#undef COUNT_NODE
default: node = INT2FIX(nodes[i]);
}
rb_hash_aset(hash, node, SIZET2NUM(nodes[i]));
}
}
return hash;
}
static VALUE
count_objects_size(int argc, VALUE *argv, VALUE os)
{
size_t counts[T_MASK+1];
size_t total = 0;
size_t i;
VALUE hash;
if (rb_scan_args(argc, argv, "01", &hash) == 1) {
if (TYPE(hash) != T_HASH)
rb_raise(rb_eTypeError, "non-hash given");
}
for (i = 0; i <= T_MASK; i++) {
counts[i] = 0;
}
rb_objspace_each_objects(cos_i, &counts[0]);
if (hash == Qnil) {
hash = rb_hash_new();
}
else if (!RHASH_EMPTY_P(hash)) {
st_foreach(RHASH_TBL(hash), set_zero_i, hash);
}
for (i = 0; i <= T_MASK; i++) {
if (counts[i]) {
VALUE type;
switch (i) {
#define COUNT_TYPE(t) case t: type = ID2SYM(rb_intern(#t)); break;
COUNT_TYPE(T_NONE);
COUNT_TYPE(T_OBJECT);
COUNT_TYPE(T_CLASS);
COUNT_TYPE(T_MODULE);
COUNT_TYPE(T_FLOAT);
COUNT_TYPE(T_STRING);
COUNT_TYPE(T_REGEXP);
COUNT_TYPE(T_ARRAY);
COUNT_TYPE(T_HASH);
COUNT_TYPE(T_STRUCT);
COUNT_TYPE(T_BIGNUM);
COUNT_TYPE(T_FILE);
COUNT_TYPE(T_DATA);
COUNT_TYPE(T_MATCH);
COUNT_TYPE(T_COMPLEX);
COUNT_TYPE(T_RATIONAL);
COUNT_TYPE(T_NIL);
COUNT_TYPE(T_TRUE);
COUNT_TYPE(T_FALSE);
COUNT_TYPE(T_SYMBOL);
COUNT_TYPE(T_FIXNUM);
COUNT_TYPE(T_UNDEF);
COUNT_TYPE(T_NODE);
COUNT_TYPE(T_ICLASS);
COUNT_TYPE(T_ZOMBIE);
#undef COUNT_TYPE
default: type = INT2NUM(i); break;
}
total += counts[i];
rb_hash_aset(hash, type, SIZET2NUM(counts[i]));
}
}
rb_hash_aset(hash, ID2SYM(rb_intern("TOTAL")), SIZET2NUM(total));
return hash;
}
static VALUE
memsize_of_m(VALUE self, VALUE obj)
{
return SIZET2NUM(memsize_of(obj));
}
