static mrb_value
mrb_hash_values(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary;
if (!h) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)){
mrb_value v = kh_value(h,k);
mrb_ary_push(mrb, ary, v);
}
}
return ary;
}
/*
* call-seq:
* mod.constants -> array
*
* Returns an array of all names of contants defined in the receiver.
*/
mrb_value
mrb_mod_constants(mrb_state *mrb, mrb_value mod)
{
mrb_value ary;
mrb_bool inherit = TRUE;
struct RClass *c = mrb_class_ptr(mod);
mrb_get_args(mrb, "|b", &inherit);
ary = mrb_ary_new(mrb);
while (c) {
iv_foreach(mrb, c->iv, const_i, &ary);
if (!inherit) break;
c = c->super;
if (c == mrb->object_class) break;
}
return ary;
}
/*
* call-seq:
* global_variables -> array
*
* Returns an array of the names of global variables.
*
* global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
*/
mrb_value
mrb_f_global_variables(mrb_state *mrb, mrb_value self)
{
iv_tbl *t = mrb->globals;
mrb_value ary = mrb_ary_new(mrb);
size_t i;
char buf[3];
iv_foreach(mrb, t, gv_i, &ary);
buf[0] = '$';
buf[2] = 0;
for (i = 1; i <= 9; ++i) {
buf[1] = (char)(i + '0');
mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern(mrb, buf, 2)));
}
return ary;
}
mrb_value
mrb_env_keys(mrb_state *mrb, mrb_value self)
{
int i;
mrb_value ary;
ary = mrb_ary_new(mrb);
for (i = 0; environ[i] != NULL; i++) {
char *str = strchr(environ[i], '=');
if (str != NULL) {
int len = str - environ[i];
mrb_ary_push(mrb, ary, mrb_str_new(mrb, environ[i], len));
}
}
return ary;
}
static mrb_value
indexable_indexes(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *object;
grn_index_datum index_datum;
grn_index_datum *index_data;
int i, n_index_data;
mrb_value mrb_indexes;
object = DATA_PTR(self);
n_index_data = grn_column_get_all_index_data(ctx, object, &index_datum, 1);
if (n_index_data == 0) {
return mrb_ary_new(mrb);
}
if (n_index_data == 1) {
index_data = &index_datum;
} else {
index_data = GRN_MALLOCN(grn_index_datum, n_index_data);
n_index_data = grn_column_get_all_index_data(ctx,
object,
index_data,
n_index_data);
}
mrb_indexes = mrb_ary_new_capa(mrb, n_index_data);
for (i = 0; i < n_index_data; i++) {
grn_mrb_data *data;
struct RClass *klass;
mrb_value args[2];
data = &(ctx->impl->mrb);
klass = mrb_class_get_under(mrb, data->module, "IndexInfo");
args[0] = grn_mrb_value_from_grn_obj(mrb, index_data[i].index);
args[1] = mrb_fixnum_value(index_data[i].section);
mrb_ary_push(mrb, mrb_indexes, mrb_obj_new(mrb, klass, 2, args));
}
if (index_data != &index_datum) {
GRN_FREE(index_data);
}
return mrb_indexes;
}
static mrb_value
mrb_hash_values(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary = mrb_ary_new(mrb);
if (!h) return ary;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)){
mrb_value v = kh_value(h,k);
if ( !mrb_special_const_p(v) )
v = mrb_obj_dup(mrb, v);
mrb_ary_push(mrb, ary, v);
}
}
return ary;
}
static mrb_value
mrb_uv_key_init(mrb_state *mrb, mrb_value self)
{
uv_key_t *key;
int err;
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "values"), mrb_ary_new(mrb));
key = (uv_key_t*)mrb_malloc(mrb, sizeof(uv_key_t));
err = uv_key_create(key);
if (err < 0) {
mrb_free(mrb, key);
mrb_uv_check_error(mrb, err);
}
DATA_PTR(self) = key;
DATA_TYPE(self) = &mrb_uv_key_type;
return self;
}
mrb_value
mrb_env_values(mrb_state *mrb, mrb_value self)
{
int i;
mrb_value ary;
ary = mrb_ary_new(mrb);
for (i = 0; environ[i] != NULL; i++) {
char *str = strchr(environ[i], '=');
if (str) {
str++;
int len = strlen(str);
mrb_ary_push(mrb, ary, mrb_str_new(mrb, str, len));
}
}
return ary;
}
int
main(int argc, char **argv)
{
mrb_state *mrb;
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting driver");
return EXIT_FAILURE;
}
#if 0
mrb_iv_set(mrb, mrb_obj_value(mrb->kernel_module),
mrb_intern(mrb, "@loaded_compiled_mrb_handles"),
mrb_ary_new(mrb));
#endif
mrbb_exec_entry_point_for_mrblib(mrb, mrb_top_self(mrb));
MRBB_EXEC_ENTRY_POINT(mrb, mrb_top_self(mrb));
mrb_close(mrb);
return EXIT_SUCCESS;
}
static mrb_value
mrb_mod_ancestors(mrb_state *mrb, mrb_value self)
{
mrb_value result;
struct RClass *c = mrb_class_ptr(self);
result = mrb_ary_new(mrb);
while (c) {
if (c->tt == MRB_TT_ICLASS) {
mrb_ary_push(mrb, result, mrb_obj_value(c->c));
}
else {
mrb_ary_push(mrb, result, mrb_obj_value(c));
}
c = c->super;
}
return result;
}
static mrb_value
indexable_index_ids(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *object;
grn_hook_entry entry;
int i;
int n_indexes;
mrb_value mrb_index_ids;
grn_obj hook_data;
object = DATA_PTR(self);
if (grn_obj_is_key_accessor(ctx, object)) {
object = grn_ctx_at(ctx, object->header.domain);
}
if (grn_obj_is_table(ctx, object)) {
entry = GRN_HOOK_INSERT;
} else if (grn_obj_is_column(ctx, object)) {
entry = GRN_HOOK_SET;
} else {
return mrb_ary_new(mrb);
}
n_indexes = grn_obj_get_nhooks(ctx, object, entry);
mrb_index_ids = mrb_ary_new_capa(mrb, n_indexes);
GRN_TEXT_INIT(&hook_data, 0);
for (i = 0; i < n_indexes; i++) {
GRN_BULK_REWIND(&hook_data);
grn_obj_get_hook(ctx, object, entry, i, &hook_data);
if (GRN_BULK_VSIZE(&hook_data) ==
sizeof(grn_obj_default_set_value_hook_data)) {
grn_obj_default_set_value_hook_data *data;
data = (grn_obj_default_set_value_hook_data *)GRN_TEXT_VALUE(&hook_data);
mrb_ary_push(mrb, mrb_index_ids, mrb_fixnum_value(data->target));
}
}
return mrb_index_ids;
}
static mrb_value
pcap_s_lookupnet(mrb_state *mrb, mrb_value self)
{
mrb_value rval;
char *cdev;
char buf_str[INET_ADDRSTRLEN+1];
bpf_u_int32 net, mask;
mrb_get_args(mrb, "s", &cdev);
if (pcap_lookupnet(cdev, &net, &mask, pcap_errbuf) == -1)
mrb_raise(mrb, E_RUNTIME_ERROR, pcap_errbuf);
rval = mrb_ary_new(mrb);
inet_ntop(AF_INET, &net, buf_str, sizeof(buf_str));
mrb_ary_push(mrb, rval, mrb_str_new(mrb, buf_str, strlen(buf_str)));
inet_ntop(AF_INET, &mask, buf_str, sizeof(buf_str));
mrb_ary_push(mrb, rval, mrb_str_new(mrb, buf_str, strlen(buf_str)));
return rval;
}
mrb_value mrb_redis_keys(mrb_state *mrb, mrb_value self)
{
mrb_value pattern, array = mrb_nil_value();
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &pattern);
redisReply *rr = redisCommand(rc, "KEYS %s", mrb_str_to_cstr(mrb, pattern));
if (rr->type == REDIS_REPLY_ARRAY) {
if (rr->elements > 0) {
int i;
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new_cstr(mrb, rr->element[i]->str));
}
}
}
freeReplyObject(rr);
return array;
}
static mrb_value
mrb_system_s_get_time(mrb_state *mrb, mrb_value self)
{
mrb_int year;
mrb_value array;
GEDI_CLOCK_st_RTC stRTC;
GEDI_CLOCK_RTCGet(&stRTC);
array = mrb_ary_new(mrb);
year = (2000 + stRTC.bYear > 2100) ? 2020 : 2000 + stRTC.bYear;
mrb_ary_push(mrb, array, mrb_fixnum_value(year));
mrb_ary_push(mrb, array, mrb_fixnum_value(stRTC.bMonth));
mrb_ary_push(mrb, array, mrb_fixnum_value(stRTC.bDay));
mrb_ary_push(mrb, array, mrb_fixnum_value(stRTC.bHour));
mrb_ary_push(mrb, array, mrb_fixnum_value(stRTC.bMinute));
mrb_ary_push(mrb, array, mrb_fixnum_value(stRTC.bSecond));
return array;
}
mrb_value
mrb_struct_define(mrb_state *mrb, const char *name, ...)
{
va_list ar;
mrb_value nm, ary;
char *mem;
if (!name) nm = mrb_nil_value();
else nm = mrb_str_new_cstr(mrb, name);
ary = mrb_ary_new(mrb);
va_start(ar, name);
while ((mem = va_arg(ar, char*)) != 0) {
mrb_sym slot = mrb_intern_cstr(mrb, mem);
mrb_ary_push(mrb, ary, mrb_symbol_value(slot));
}
va_end(ar);
return make_struct(mrb, nm, ary, struct_class(mrb));
}
/*
* call-seq:
* Struct.new( [aString] [, aSym]+> ) -> StructClass
* StructClass.new(arg, ...) -> obj
* StructClass[arg, ...] -> obj
*
* Creates a new class, named by <i>aString</i>, containing accessor
* methods for the given symbols. If the name <i>aString</i> is
* omitted, an anonymous structure class will be created. Otherwise,
* the name of this struct will appear as a constant in class
* <code>Struct</code>, so it must be unique for all
* <code>Struct</code>s in the system and should start with a capital
* letter. Assigning a structure class to a constant effectively gives
* the class the name of the constant.
*
* <code>Struct::new</code> returns a new <code>Class</code> object,
* which can then be used to create specific instances of the new
* structure. The number of actual parameters must be
* less than or equal to the number of attributes defined for this
* class; unset parameters default to <code>nil</code>. Passing too many
* parameters will raise an <code>ArgumentError</code>.
*
* The remaining methods listed in this section (class and instance)
* are defined for this generated class.
*
* # Create a structure with a name in Struct
* Struct.new("Customer", :name, :address) #=> Struct::Customer
* Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main">
*
* # Create a structure named by its constant
* Customer = Struct.new(:name, :address) #=> Customer
* Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main">
*/
static mrb_value
mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
{
mrb_value name, rest;
mrb_value *pargv;
mrb_int argcnt;
mrb_int i;
mrb_value b, st;
mrb_sym id;
mrb_value *argv;
mrb_int argc;
name = mrb_nil_value();
rest = mrb_nil_value();
mrb_get_args(mrb, "*&", &argv, &argc, &b);
if (argc == 0) { /* special case to avoid crash */
rest = mrb_ary_new(mrb);
}
else {
if (argc > 0) name = argv[0];
pargv = &argv[1];
argcnt = argc-1;
if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
name = mrb_nil_value();
pargv = &argv[0];
argcnt++;
}
rest = mrb_ary_new_from_values(mrb, argcnt, pargv);
for (i=0; i<RARRAY_LEN(rest); i++) {
id = mrb_obj_to_sym(mrb, RARRAY_PTR(rest)[i]);
mrb_ary_set(mrb, rest, i, mrb_symbol_value(id));
}
}
st = make_struct(mrb, name, rest, mrb_class_ptr(klass));
if (!mrb_nil_p(b)) {
mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(st));
}
return st;
}
mrb_value
mrb_hash_keys(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary, *p;
if (!h || kh_size(h) == 0) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
mrb_ary_set(mrb, ary, kh_size(h)-1, mrb_nil_value());
p = RARRAY_PTR(ary);
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
mrb_value kv = kh_key(h,k);
mrb_hash_value hv = kh_value(h,k);
p[hv.n] = kv;
}
}
return ary;
}
mrb_value
mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
{
mrb_value ary;
struct RClass* klass;
klass = mrb_class(mrb, obj);
ary = mrb_ary_new(mrb);
if (klass && (klass->tt == MRB_TT_SCLASS)) {
method_entry_loop(mrb, klass, ary);
klass = klass->super;
}
if (recur) {
while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
method_entry_loop(mrb, klass, ary);
klass = klass->super;
}
}
return ary;
}
mrb_value
class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass, int obj)
{
mrb_value ary;
struct RClass* oldklass;
ary = mrb_ary_new(mrb);
oldklass = 0;
while (klass && (klass != oldklass)) {
method_entry_loop(mrb, klass, ary);
if ((klass->tt == MRB_TT_ICLASS) ||
(klass->tt == MRB_TT_SCLASS)) {
}
else {
if (!recur) break;
}
oldklass = klass;
klass = klass->super;
}
return ary;
}
/*
* call-seq:
* obj.instance_variables -> array
*
* Returns an array of instance variable names for the receiver. Note
* that simply defining an accessor does not create the corresponding
* instance variable.
*
* class Fred
* attr_accessor :a1
* def initialize
* @iv = 3
* end
* end
* Fred.new.instance_variables #=> [:@iv]
*/
mrb_value
mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
{
mrb_value ary;
kh_iv_t *h = RCLASS_IV_TBL(self);
int i;
const char* p;
ary = mrb_ary_new(mrb);
if (h) {
for (i=0;i<kh_end(h);i++) {
if (kh_exist(h, i)) {
p = mrb_sym2name(mrb, kh_key(h,i));
if (*p == '@') {
if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, p));
}
}
}
}
return ary;
}
mrb_value mrb_redis_hkeys(mrb_state *mrb, mrb_value self)
{
mrb_value key, array = mrb_nil_value();
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"HKEYS", RSTRING_PTR(key)};
size_t lens[] = {5, RSTRING_LEN(key)};
redisReply *rr = redisCommandArgv(rc, 2, argv, lens);
if (rr->type == REDIS_REPLY_ARRAY) {
if (rr->elements > 0) {
int i;
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new(mrb, rr->element[i]->str, rr->element[i]->len));
}
}
}
freeReplyObject(rr);
return array;
}
mrb_value mrb_redis_smembers(mrb_state *mrb, mrb_value self)
{
int i;
mrb_value array, key;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
redisReply *rr = redisCommand(rc, "SMEMBERS %s", mrb_str_to_cstr(mrb, key));
if (rr->type == REDIS_REPLY_ARRAY) {
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new(mrb, rr->element[i]->str, rr->element[i]->len));
}
} else {
freeReplyObject(rr);
return mrb_nil_value();
}
freeReplyObject(rr);
return array;
}
static mrb_value
row_to_value(mrb_state* mrb, sqlite3_stmt* stmt) {
int i;
int count = sqlite3_column_count(stmt);
mrb_value a = mrb_ary_new(mrb);
for (i = 0; i < count; i++) {
switch (sqlite3_column_type(stmt, i)) {
case SQLITE_INTEGER:
{
sqlite3_int64 value = sqlite3_column_int64(stmt, i);
mrb_ary_push(mrb, a, mrb_fixnum_value((mrb_int) value));
}
break;
case SQLITE_FLOAT:
{
double value = sqlite3_column_double(stmt, i);
mrb_ary_push(mrb, a, mrb_float_value(mrb, value));
}
break;
case SQLITE_BLOB:
{
int size = sqlite3_column_bytes(stmt, i);
const char* ptr = sqlite3_column_blob(stmt, i);
mrb_ary_push(mrb, a, mrb_str_new(mrb, ptr, size));
}
break;
case SQLITE_NULL:
mrb_ary_push(mrb, a, mrb_nil_value());
break;
case SQLITE_TEXT:
{
const char* value = (const char*) sqlite3_column_text(stmt, i);
mrb_ary_push(mrb, a, mrb_str_new_cstr(mrb, value));
}
break;
}
}
return a;
}
static void
handler(u_char *user, const struct pcap_pkthdr *pkthdr, const u_char *data)
{
mrb_value rval;
char timestamp[32];
struct capture_object *cap;
char *data_p = (char *)data;
cap = (struct capture_object *)user;
rval = mrb_ary_new(cap->mrb);
timestamp[0] = '\0';
snprintf(timestamp, sizeof(timestamp)-1, "%ld.%ld",
(long)pkthdr->ts.tv_sec, (long)pkthdr->ts.tv_usec);
mrb_ary_push(cap->mrb, rval,
mrb_str_new(cap->mrb, timestamp, strlen(timestamp)));
mrb_ary_push(cap->mrb, rval, mrb_fixnum_value(pkthdr->caplen));
mrb_ary_push(cap->mrb, rval, mrb_fixnum_value(pkthdr->len));
mrb_ary_push(cap->mrb, rval, mrb_str_new(cap->mrb, data_p, pkthdr->caplen));
cap->cap_data = rval;
return;
}
mrb_value mrb_redis_lrange(mrb_state *mrb, mrb_value self)
{
int i;
mrb_value list, array;
mrb_int arg1, arg2;
mrb_get_args(mrb, "oii", &list, &arg1, &arg2);
redisContext *rc = mrb_redis_get_context(mrb, self);
redisReply *rr = redisCommand(rc,"LRANGE %s %d %d", RSTRING_PTR(list), arg1, arg2);
if (rr->type == REDIS_REPLY_ARRAY) {
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new2(mrb, rr->element[i]->str));
}
} else {
freeReplyObject(rr);
return mrb_nil_value();
}
freeReplyObject(rr);
return array;
}
int main(int argc,const char *argv[])
{
mrb_state *mrb;
mrb_value ret;
// initialize mruby
if (!(mrb = mrb_open()))
{
fprintf(stderr,"%s: could not initialize mruby\n",argv[0]);
return -1;
}
mrb_value args = mrb_ary_new(mrb);
int i;
// convert argv into mruby strings
for (i=1; i<argc; i++)
{
mrb_ary_push(mrb, args, mrb_str_new_cstr(mrb,argv[i]));
}
mrb_define_global_const(mrb, "ARGV", args);
// load the compiled library
ret = lib_init(mrb);
// check for exception
if (mrb->exc)
{
// print exception
mrb_print_error(mrb);
}
// cleanup
mrb_close(mrb);
return mrb->exc != NULL;
}
mrb_value
mrb_restore_backtrace(mrb_state *mrb)
{
int i;
mrb_value backtrace;
backtrace = mrb_ary_new(mrb);
for (i = 0; i < mrb->backtrace.n; i++) {
int ai;
mrb_backtrace_entry *entry;
mrb_value mrb_entry;
char buf[32];
ai = mrb_gc_arena_save(mrb);
entry = &(mrb->backtrace.entries[i]);
mrb_entry = mrb_str_new_cstr(mrb, entry->filename);
snprintf(buf, sizeof(buf), ":%d", entry->lineno);
mrb_str_cat_cstr(mrb, mrb_entry, buf);
if (entry->method_id != 0) {
mrb_str_cat_lit(mrb, mrb_entry, ":in ");
if (entry->klass) {
mrb_str_cat_cstr(mrb, mrb_entry, mrb_class_name(mrb, entry->klass));
mrb_str_cat(mrb, mrb_entry, &entry->sep, 1);
}
mrb_str_cat_cstr(mrb, mrb_entry, mrb_sym2name(mrb, entry->method_id));
}
mrb_ary_push(mrb, backtrace, mrb_entry);
mrb_gc_arena_restore(mrb, ai);
}
return backtrace;
}
/*
* call-seq:
* string.lines -> array of string
*
* Returns strings per line;
*
* a = "abc\ndef"
* a.lines #=> ["abc\n", "def"]
*/
static mrb_value
mrb_str_lines(mrb_state *mrb, mrb_value self)
{
mrb_value result;
mrb_value blk;
int ai;
mrb_int len;
mrb_value arg;
char *p = RSTRING_PTR(self), *t;
char *e = p + RSTRING_LEN(self);
mrb_get_args(mrb, "&", &blk);
result = mrb_ary_new(mrb);
if (!mrb_nil_p(blk)) {
while (p < e) {
t = p;
while (p < e && *p != '\n') p++;
if (*p == '\n') p++;
len = (mrb_int) (p - t);
arg = mrb_str_new(mrb, t, len);
mrb_yield_argv(mrb, blk, 1, &arg);
}
return self;
}
while (p < e) {
ai = mrb_gc_arena_save(mrb);
t = p;
while (p < e && *p != '\n') p++;
if (*p == '\n') p++;
len = (mrb_int) (p - t);
mrb_ary_push(mrb, result, mrb_str_new(mrb, t, len));
mrb_gc_arena_restore(mrb, ai);
}
return result;
}
static mrb_value
find_file_check(mrb_state *mrb, mrb_value path, mrb_value fname, mrb_value ext)
{
FILE *fp;
char fpath[MAXPATHLEN];
mrb_value filepath = mrb_str_dup(mrb, path);
#ifdef _WIN32
if (RSTRING_PTR(fname)[1] == ':') {
#else
if (RSTRING_PTR(fname)[0] == '/') {
#endif
/* when absolute path */
mrb_funcall(mrb, filepath, "replace", 1, fname);
} else {
mrb_str_cat2(mrb, filepath, "/");
mrb_str_buf_append(mrb, filepath, fname);
}
if (!mrb_string_p(filepath)) {
return mrb_nil_value();
}
if (mrb_string_p(ext)) {
mrb_str_buf_append(mrb, filepath, ext);
}
debug("filepath: %s\n", RSTRING_PTR(filepath));
if (realpath(RSTRING_PTR(filepath), fpath) == NULL) {
return mrb_nil_value();
}
debug("fpath: %s\n", fpath);
fp = fopen(fpath, "r");
if (fp == NULL) {
return mrb_nil_value();
}
fclose(fp);
return mrb_str_new_cstr(mrb, fpath);
}
static mrb_value
find_file(mrb_state *mrb, mrb_value filename, int comp)
{
char *ext, *ptr, *tmp;
mrb_value exts;
int i, j;
char *fname = RSTRING_PTR(filename);
mrb_value filepath = mrb_nil_value();
mrb_value load_path = mrb_obj_dup(mrb, mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$:")));
load_path = mrb_check_array_type(mrb, load_path);
if(mrb_nil_p(load_path)) {
mrb_raise(mrb, E_RUNTIME_ERROR, "invalid $:");
return mrb_undef_value();
}
tmp = ptr = fname;
while (tmp) {
if ((tmp = strchr(ptr, '/')) || (tmp = strchr(ptr, '\\'))) {
ptr = tmp + 1;
}
}
ext = strrchr(ptr, '.');
exts = mrb_ary_new(mrb);
if (ext == NULL && comp) {
mrb_ary_push(mrb, exts, mrb_str_new_cstr(mrb, ".rb"));
mrb_ary_push(mrb, exts, mrb_str_new_cstr(mrb, ".mrb"));
mrb_ary_push(mrb, exts, mrb_str_new_cstr(mrb, ".so"));
} else {
mrb_ary_push(mrb, exts, mrb_nil_value());
}
/* when a filename start with '.', $: = ['.'] */
if (*fname == '.') {
load_path = mrb_ary_new(mrb);
mrb_ary_push(mrb, load_path, mrb_str_new_cstr(mrb, "."));
}
for (i = 0; i < RARRAY_LEN(load_path); i++) {
for (j = 0; j < RARRAY_LEN(exts); j++) {
filepath = find_file_check(
mrb,
mrb_ary_entry(load_path, i),
filename,
mrb_ary_entry(exts, j));
if (!mrb_nil_p(filepath)) {
return filepath;
}
}
}
mrb_load_fail(mrb, filename, "cannot load such file");
return mrb_nil_value();
}
void
test_mrb_field_write_barrier(void)
{
mrb_state *mrb = mrb_open();
struct RBasic *obj, *value;
puts("test_mrb_field_write_barrier");
mrb->is_generational_gc_mode = FALSE;
obj = mrb_basic_ptr(mrb_ary_new(mrb));
value = mrb_basic_ptr(mrb_str_new_lit(mrb, "value"));
paint_black(obj);
paint_partial_white(mrb,value);
puts(" in GC_STATE_MARK");
mrb->gc_state = GC_STATE_MARK;
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(is_gray(value));
puts(" in GC_STATE_SWEEP");
paint_partial_white(mrb,value);
mrb->gc_state = GC_STATE_SWEEP;
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(obj->color & mrb->current_white_part);
mrb_assert(value->color & mrb->current_white_part);
puts(" fail with black");
mrb->gc_state = GC_STATE_MARK;
paint_white(obj);
paint_partial_white(mrb,value);
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(obj->color & mrb->current_white_part);
puts(" fail with gray");
mrb->gc_state = GC_STATE_MARK;
paint_black(obj);
paint_gray(value);
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(is_gray(value));
{
puts("test_mrb_field_write_barrier_value");
obj = mrb_basic_ptr(mrb_ary_new(mrb));
mrb_value value = mrb_str_new_lit(mrb, "value");
paint_black(obj);
paint_partial_white(mrb, mrb_basic_ptr(value));
mrb->gc_state = GC_STATE_MARK;
mrb_field_write_barrier_value(mrb, obj, value);
mrb_assert(is_gray(mrb_basic_ptr(value)));
}
mrb_close(mrb);
}
