void
Init_load(void)
{
#undef rb_intern
#define rb_intern(str) rb_intern2((str), strlen(str))
rb_vm_t *vm = GET_VM();
static const char var_load_path[] = "$:";
ID id_load_path = rb_intern2(var_load_path, sizeof(var_load_path)-1);
rb_define_hooked_variable(var_load_path, (VALUE*)vm, load_path_getter, rb_gvar_readonly_setter);
rb_alias_variable(rb_intern("$-I"), id_load_path);
rb_alias_variable(rb_intern("$LOAD_PATH"), id_load_path);
vm->load_path = rb_ary_new();
vm->expanded_load_path = rb_ary_tmp_new(0);
vm->load_path_snapshot = rb_ary_tmp_new(0);
vm->load_path_check_cache = 0;
rb_define_virtual_variable("$\"", get_loaded_features, 0);
rb_define_virtual_variable("$LOADED_FEATURES", get_loaded_features, 0);
vm->loaded_features = rb_ary_new();
vm->loaded_features_snapshot = rb_ary_tmp_new(0);
vm->loaded_features_index = st_init_strtable();
rb_define_global_function("load", rb_f_load, -1);
rb_define_global_function("require", rb_f_require, 1);
rb_define_global_function("require_relative", rb_f_require_relative, 1);
rb_define_method(rb_cModule, "autoload", rb_mod_autoload, 2);
rb_define_method(rb_cModule, "autoload?", rb_mod_autoload_p, 1);
rb_define_global_function("autoload", rb_f_autoload, 2);
rb_define_global_function("autoload?", rb_f_autoload_p, 1);
ruby_dln_librefs = rb_ary_tmp_new(0);
rb_gc_register_mark_object(ruby_dln_librefs);
}
void avro_raw_map_clear(avro_raw_map_t *map)
{
avro_raw_map_free_keys(map);
avro_raw_array_clear(&map->elements);
st_free_table((st_table *) map->indices_by_key);
map->indices_by_key = st_init_strtable();
}
osm_db_domain_t *osm_db_domain_init(IN osm_db_t * const p_db,
IN char *domain_name)
{
osm_db_domain_t *p_domain;
osm_db_domain_imp_t *p_domain_imp;
int dir_name_len;
osm_log_t *p_log = p_db->p_log;
FILE *p_file;
OSM_LOG_ENTER(p_log);
/* allocate a new domain object */
p_domain = (osm_db_domain_t *) malloc(sizeof(osm_db_domain_t));
CL_ASSERT(p_domain != NULL);
p_domain_imp =
(osm_db_domain_imp_t *) malloc(sizeof(osm_db_domain_imp_t));
CL_ASSERT(p_domain_imp != NULL);
dir_name_len = strlen(((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name);
/* set the domain file name */
p_domain_imp->file_name =
(char *)malloc(sizeof(char) * (dir_name_len) + strlen(domain_name) +
2);
CL_ASSERT(p_domain_imp->file_name != NULL);
strcpy(p_domain_imp->file_name,
((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name);
strcat(p_domain_imp->file_name, domain_name);
/* make sure the file exists - or exit if not writable */
p_file = fopen(p_domain_imp->file_name, "a+");
if (!p_file) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6102: "
"Failed to open the db file:%s\n",
p_domain_imp->file_name);
free(p_domain_imp);
free(p_domain);
p_domain = NULL;
goto Exit;
}
fclose(p_file);
/* initialize the hash table object */
p_domain_imp->p_hash = st_init_strtable();
CL_ASSERT(p_domain_imp->p_hash != NULL);
p_domain->p_db = p_db;
cl_list_insert_tail(&p_db->domains, p_domain);
p_domain->p_domain_imp = p_domain_imp;
cl_spinlock_construct(&p_domain_imp->lock);
cl_spinlock_init(&p_domain_imp->lock);
Exit:
OSM_LOG_EXIT(p_log);
return p_domain;
}
static VALUE cov_install_coverage_hook(VALUE self) {
if (!coverage_hook_set_p) {
if (!coverinfo) coverinfo = st_init_strtable();
coverage_hook_set_p = 1;
/* TODO: allow C_CALL too, since it's supported already
* the overhead is around ~30%, tested on typo */
rb_add_event_hook(coverage_event_coverage_hook, RUBY_EVENT_ALL & ~RUBY_EVENT_C_CALL & ~RUBY_EVENT_C_RETURN & ~RUBY_EVENT_CLASS);
return Qtrue;
} else return Qfalse;
}
RUBY_FUNC_EXPORTED void
ruby_init_ext(const char *name, void (*init)(void))
{
st_table *loading_tbl = get_loading_table();
if (rb_provided(name))
return;
if (!loading_tbl) {
GET_VM()->loading_table = loading_tbl = st_init_strtable();
}
st_update(loading_tbl, (st_data_t)name, register_init_ext, (st_data_t)init);
}
size_t kari_identifier_uniqid(char* identifier)
{
size_t tmp_uniqid = 0;
if(uniqids == NULL) {
uniqids = st_init_strtable();
}
if(!st_lookup(uniqids, (st_data_t)identifier, (st_data_t*)&tmp_uniqid)) {
tmp_uniqid = uniqid_ai++;
st_insert(uniqids, (st_data_t)identifier, tmp_uniqid);
}
return tmp_uniqid;
}
PerlFMM*
PerlFMM_create(SV *class_sv) {
PerlFMM *state;
PERL_UNUSED_VAR(class_sv);
Newz(1234, state, 1, PerlFMM);
state->magic = NULL;
state->error = NULL;
state->ext = st_init_strtable();
return state;
}
static struct traceobj_arg *
get_traceobj_arg(void)
{
if (tmp_trace_arg == 0) {
tmp_trace_arg = ALLOC_N(struct traceobj_arg, 1);
MEMZERO(tmp_trace_arg, struct traceobj_arg, 1);
tmp_trace_arg->running = 0;
tmp_trace_arg->keys = 0;
tmp_trace_arg->vals = VAL_COUNT | VAL_OLDCOUNT | VAL_TOTAL_AGE | VAL_MAX_AGE | VAL_MIN_AGE | VAL_MEMSIZE;
tmp_trace_arg->aggregate_table = st_init_table(&memcmp_hash_type);
tmp_trace_arg->object_table = st_init_numtable();
tmp_trace_arg->str_table = st_init_strtable();
tmp_trace_arg->freed_allocation_info = NULL;
tmp_trace_arg->lifetime_table = NULL;
}
static rbkit_logger * get_trace_logger() {
if (logger == 0) {
logger = ALLOC_N(rbkit_logger, 1);
logger->enabled = Qfalse;
logger->sampling_profiler_enabled = Qfalse;
logger->newobj_trace = 0;
logger->freeobj_trace = 0;
logger->object_table = st_init_numtable();
logger->str_table = st_init_strtable();
logger->sbuf = msgpack_sbuffer_new();
logger->msgpacker = msgpack_packer_new(logger->sbuf, msgpack_sbuffer_write);
logger->data = 0;
}
return logger;
}
static VALUE
memprof_stats(int argc, VALUE *argv, VALUE self)
{
st_table *tmp_table;
struct results res;
int i;
VALUE str;
FILE *out = NULL;
if (!track_objs)
rb_raise(rb_eRuntimeError, "object tracking disabled, call Memprof.start first");
rb_scan_args(argc, argv, "01", &str);
if (RTEST(str)) {
out = fopen(StringValueCStr(str), "w");
if (!out)
rb_raise(rb_eArgError, "unable to open output file");
}
track_objs = 0;
tmp_table = st_init_strtable();
st_foreach(objs, objs_tabulate, (st_data_t)tmp_table);
res.num_entries = 0;
res.entries = malloc(sizeof(char*) * tmp_table->num_entries);
st_foreach(tmp_table, objs_to_array, (st_data_t)&res);
st_free_table(tmp_table);
qsort(res.entries, res.num_entries, sizeof(char*), &memprof_strcmp);
for (i=0; i < res.num_entries; i++) {
fprintf(out ? out : stderr, "%s\n", res.entries[i]);
free(res.entries[i]);
}
free(res.entries);
if (out)
fclose(out);
track_objs = 1;
return Qnil;
}
static st_table *
sym_hash(struct exec *hdrp, struct nlist *syms)
{
st_table *tbl;
struct nlist *sym = syms;
struct nlist *end = syms + (hdrp->a_syms / sizeof(struct nlist));
tbl = st_init_strtable();
if (tbl == NULL) {
dln_errno = errno;
return NULL;
}
while (sym < end) {
st_insert(tbl, sym->n_un.n_name, sym);
sym++;
}
return tbl;
}
static zoneinfo_t timezone_cached_get(const char *name)
{
st_data_t key = (st_data_t)name, value = 0;
// if(!tz_cache) tz_cache = st_init_strcasetable();
if(!tz_cache) tz_cache = st_init_strtable();
st_lookup(tz_cache, key, &value);
if (!value) {
zoneinfo_t tz = loadzone(name);
if (!tz)
rb_raise(rb_eArgError, "time zone \"%s\" not found", name);
st_insert(tz_cache, (st_data_t)name, (st_data_t)tz);
value = (st_data_t)tz;
}
return (zoneinfo_t)value;
}
static char *
load_lock(const char *ftptr)
{
st_data_t data;
st_table *loading_tbl = get_loading_table();
if (!loading_tbl || !st_lookup(loading_tbl, (st_data_t)ftptr, &data)) {
/* loading ruby library should be serialized. */
if (!loading_tbl) {
GET_VM()->loading_table = loading_tbl = st_init_strtable();
}
/* partial state */
ftptr = ruby_strdup(ftptr);
data = (st_data_t)rb_thread_shield_new();
st_insert(loading_tbl, (st_data_t)ftptr, data);
return (char *)ftptr;
}
else if (RB_TYPE_P((VALUE)data, T_NODE) && nd_type((VALUE)data) == NODE_MEMO) {
NODE *memo = RNODE(data);
void (*init)(void) = (void (*)(void))memo->nd_cfnc;
data = (st_data_t)rb_thread_shield_new();
st_insert(loading_tbl, (st_data_t)ftptr, data);
(*init)();
return (char *)"";
}
if (RTEST(ruby_verbose)) {
rb_warning("loading in progress, circular require considered harmful - %s", ftptr);
rb_backtrace_print_to(rb_stderr);
}
switch (rb_thread_shield_wait((VALUE)data)) {
case Qfalse:
data = (st_data_t)ftptr;
st_insert(loading_tbl, data, (st_data_t)rb_thread_shield_new());
return 0;
case Qnil:
return 0;
}
return (char *)ftptr;
}
lumi_world_t *
lumi_world_alloc()
{
lumi_world_t *world = SHOE_ALLOC(lumi_world_t);
SHOE_MEMZERO(world, lumi_world_t, 1);
world->apps = rb_ary_new();
world->msgs = rb_ary_new();
world->mainloop = FALSE;
world->image_cache = st_init_strtable();
world->blank_image = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
world->blank_cache = SHOE_ALLOC(lumi_cached_image);
world->blank_cache->surface = world->blank_image;
world->blank_cache->pattern = NULL;
world->blank_cache->width = 1;
world->blank_cache->height = 1;
world->blank_cache->mtime = 0;
world->default_font = pango_font_description_new();
pango_font_description_set_family(world->default_font, "Arial");
pango_font_description_set_absolute_size(world->default_font, 14. * PANGO_SCALE * (96./72.));
rb_gc_register_address(&world->apps);
rb_gc_register_address(&world->msgs);
return world;
}
static char *
load_lock(const char *ftptr)
{
st_data_t data;
st_table *loading_tbl = get_loading_table();
if (!loading_tbl || !st_lookup(loading_tbl, (st_data_t)ftptr, &data)) {
/* loading ruby library should be serialized. */
if (!loading_tbl) {
GET_VM()->loading_table = loading_tbl = st_init_strtable();
}
/* partial state */
ftptr = ruby_strdup(ftptr);
data = (st_data_t)rb_barrier_new();
st_insert(loading_tbl, (st_data_t)ftptr, data);
return (char *)ftptr;
}
if (RTEST(ruby_verbose)) {
rb_warning("loading in progress, circular require considered harmful - %s", ftptr);
rb_backtrace();
}
return RTEST(rb_barrier_wait((VALUE)data)) ? (char *)ftptr : 0;
}
/*
* call-seq:
* Raindrops::Linux.tcp_listener_stats([addrs[, sock]]) => hash
*
* If specified, +addr+ may be a string or array of strings representing
* listen addresses to filter for. Returns a hash with given addresses as
* keys and ListenStats objects as the values or a hash of all addresses.
*
* addrs = %w(0.0.0.0:80 127.0.0.1:8080)
*
* If +addr+ is nil or not specified, all (IPv4) addresses are returned.
* If +sock+ is specified, it should be a Raindrops::InetDiagSock object.
*/
static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
{
VALUE rv = rb_hash_new();
struct nogvl_args args;
VALUE addrs, sock;
rb_scan_args(argc, argv, "02", &addrs, &sock);
/*
* allocating page_size instead of OP_LEN since we'll reuse the
* buffer for recvmsg() later, we already checked for
* OPLEN <= page_size at initialization
*/
args.iov[2].iov_len = OPLEN;
args.iov[2].iov_base = alloca(page_size);
args.table = NULL;
if (NIL_P(sock))
sock = rb_funcall(cIDSock, id_new, 0);
args.fd = my_fileno(sock);
switch (TYPE(addrs)) {
case T_STRING:
rb_hash_aset(rv, addrs, tcp_stats(&args, addrs));
return rv;
case T_ARRAY: {
long i;
long len = RARRAY_LEN(addrs);
VALUE cur;
if (len == 1) {
cur = rb_ary_entry(addrs, 0);
rb_hash_aset(rv, cur, tcp_stats(&args, cur));
return rv;
}
for (i = 0; i < len; i++) {
union any_addr check;
VALUE cur = rb_ary_entry(addrs, i);
parse_addr(&check, cur);
rb_hash_aset(rv, cur, Qtrue);
}
/* fall through */
}
case T_NIL:
args.table = st_init_strtable();
gen_bytecode_all(&args.iov[2]);
break;
default:
rb_raise(rb_eArgError,
"addr must be an array of strings, a string, or nil");
}
nl_errcheck(rb_thread_io_blocking_region(diag, &args, args.fd));
st_foreach(args.table, NIL_P(addrs) ? st_to_hash : st_AND_hash, rv);
st_free_table(args.table);
/* let GC deal with corner cases */
if (argc < 2) rb_io_close(sock);
return rv;
}
static int
dln_init(const char *prog)
{
char *file, fbuf[MAXPATHLEN];
int fd;
struct exec hdr;
struct nlist *syms;
if (dln_init_p == 1) return 0;
file = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf));
if (file == NULL || (fd = open(file, O_RDONLY)) < 0) {
dln_errno = errno;
return -1;
}
if (load_header(fd, &hdr, 0) == -1) return -1;
syms = load_sym(fd, &hdr, 0);
if (syms == NULL) {
close(fd);
return -1;
}
sym_tbl = sym_hash(&hdr, syms);
if (sym_tbl == NULL) { /* file may be start with #! */
char c = '\0';
char buf[MAXPATHLEN];
char *p;
free(syms);
lseek(fd, 0L, 0);
if (read(fd, &c, 1) == -1) {
dln_errno = errno;
return -1;
}
if (c != '#') goto err_noexec;
if (read(fd, &c, 1) == -1) {
dln_errno = errno;
return -1;
}
if (c != '!') goto err_noexec;
p = buf;
/* skip forwarding spaces */
while (read(fd, &c, 1) == 1) {
if (c == '\n') goto err_noexec;
if (c != '\t' && c != ' ') {
*p++ = c;
break;
}
}
/* read in command name */
while (read(fd, p, 1) == 1) {
if (*p == '\n' || *p == '\t' || *p == ' ') break;
p++;
if (p-buf >= MAXPATHLEN) {
dln_errno = ENAMETOOLONG;
return -1;
}
}
*p = '\0';
return dln_init(buf);
}
dln_init_p = 1;
undef_tbl = st_init_strtable();
close(fd);
return 0;
err_noexec:
close(fd);
dln_errno = DLN_ENOEXEC;
return -1;
}
void avro_raw_map_init(avro_raw_map_t *map, size_t element_size)
{
memset(map, 0, sizeof(avro_raw_map_t));
avro_raw_array_init(&map->elements, raw_entry_size(element_size));
map->indices_by_key = st_init_strtable();
}
