static mrb_value
mrb_system_s_sdk_version(mrb_state *mrb, mrb_value self)
{
char version[32]="\0";
unsigned int major=0,minor=0,release=0,build=0;
GEDI_VersionGet(&major, &minor, &release, &build);
sprintf(version, "%d.%d.%d.%d", major, minor, release, build);
return mrb_str_new_cstr(mrb, version);
}
static mrb_value
mrb_file_basename(mrb_state *mrb, mrb_value klass)
{
// NOTE: Do not use mrb_locale_from_utf8 here
#if defined(_WIN32) || defined(_WIN64)
char bname[_MAX_DIR];
char extname[_MAX_EXT];
char *path;
size_t ridx;
char buffer[_MAX_DIR + _MAX_EXT];
mrb_value s;
mrb_get_args(mrb, "S", &s);
path = mrb_str_to_cstr(mrb, s);
ridx = strlen(path);
if (ridx > 0) {
ridx--;
while (ridx > 0 && (path[ridx] == '/' || path[ridx] == '\\')) {
path[ridx] = '\0';
ridx--;
}
if (strncmp(path, "/", 2) == 0) {
return mrb_str_new_cstr(mrb, path);
}
}
_splitpath((const char*)path, NULL, NULL, bname, extname);
snprintf(buffer, _MAX_DIR + _MAX_EXT, "%s%s", bname, extname);
return mrb_str_new_cstr(mrb, buffer);
#else
char *bname, *path;
mrb_value s;
mrb_get_args(mrb, "S", &s);
path = mrb_str_to_cstr(mrb, s);
if ((bname = basename(path)) == NULL) {
mrb_sys_fail(mrb, "basename");
}
if (strncmp(bname, "//", 3) == 0) bname[1] = '\0'; /* patch for Cygwin */
return mrb_str_new_cstr(mrb, bname);
#endif
}
void
mrb_init_file(mrb_state *mrb)
{
struct RClass *io, *file, *cnst;
io = mrb_class_get(mrb, "IO");
file = mrb_define_class(mrb, "File", io);
MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "symlink", mrb_file_s_symlink, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST());
mrb_define_class_method(mrb, file, "readlink", mrb_file_s_readlink, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE());
mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1));
mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
mrb_define_method(mrb, file, "mtime", mrb_file_mtime, MRB_ARGS_NONE());
cnst = mrb_define_module_under(mrb, file, "Constants");
mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR));
#if defined(_WIN32) || defined(_WIN64)
mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
#else
mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
#endif
mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
}
static mrb_value mrb_cgroup_create(mrb_state *mrb, mrb_value self)
{
int code;
mrb_cgroup_context *mrb_cg_cxt = mrb_cgroup_get_context(mrb, self, "mrb_cgroup_context");
// BUG1 : cgroup_create_cgroup returns an error(Invalid argument:50016:ECGOTHER), despite actually succeeding
// BUG2 : cgroup_delete_cgroup returns an error(This kernel does not support this feature:50029:ECGCANTSETVALUE), despite actually succeeding
// REFS : libcgroup/src/api.c 1620 - 1630 comments
//
// error = cg_set_control_value(path,
// cgroup->controller[k]->values[j]->value);
// /*
// * Should we undo, what we've done in the loops above?
// * An error should not be treated as fatal, since we
// * have several read-only files and several files that
// * are only conditionally created in the child.
// *
// * A middle ground would be to track that there
// * was an error and return a diagnostic value--
// * callers don't get context for the error, but can
// * ignore it specifically if they wish.
// */
// if (error) {
// cgroup_dbg("failed to set %s: %s (%d)\n",
// path,
// cgroup_strerror(error), error);
// retval = ECGCANTSETVALUE;
// continue;
// }
//
if ((code = cgroup_create_cgroup(mrb_cg_cxt->cg, 1)) && code != ECGOTHER && code != ECGCANTSETVALUE) {
mrb_raisef(mrb
, E_RUNTIME_ERROR
, "cgroup_create failed: %S(%S)"
, mrb_str_new_cstr(mrb, cgroup_strerror(code))
, mrb_fixnum_value(code)
);
}
mrb_cg_cxt->already_exist = 1;
mrb_iv_set(mrb
, self
, mrb_intern_cstr(mrb, "mrb_cgroup_context")
, mrb_obj_value(Data_Wrap_Struct(mrb
, mrb->object_class
, &mrb_cgroup_context_type
, (void *)mrb_cg_cxt)
)
);
return self;
}
static mrb_value
mrb_sce_init(mrb_state *mrb, mrb_value self)
{
mrb_value c, e2c, m, str;
mrb_int n;
int argc, no_errno = 0;
char buf[20];
argc = mrb_get_args(mrb, "o|i", &m, &n);
if (argc == 1) {
if (mrb_type(m) == MRB_TT_FIXNUM) {
n = mrb_fixnum(m);
m = mrb_nil_value();
} else {
no_errno = 1;
}
}
if (!no_errno) {
e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class"));
c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value());
if (!mrb_nil_p(c)) {
mrb_basic_ptr(self)->c = mrb_class_ptr(c);
str = mrb_str_new_cstr(mrb, strerror(n));
} else {
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n));
str = mrb_str_new_cstr(mrb, "Unknown error: ");
snprintf(buf, sizeof(buf), "%d", (int)n);
mrb_str_cat2(mrb, str, buf);
}
} else {
str = mrb_str_new_cstr(mrb, "unknown error");
}
if (!mrb_nil_p(m)) {
mrb_str_cat2(mrb, str, " - ");
mrb_str_append(mrb, str, m);
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str);
return self;
}
static void
mrb_load_fail(mrb_state *mrb, mrb_value path, const char *err)
{
mrb_value mesg, exc;
mesg = mrb_str_new_cstr(mrb, err);
mrb_str_cat_lit(mrb, mesg, " -- ");
mrb_str_cat_str(mrb, mesg, path);
exc = mrb_funcall(mrb, mrb_obj_value(E_LOAD_ERROR), "new", 1, mesg);
mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "path"), path);
mrb_exc_raise(mrb, exc);
}
static mrb_value
mrb_file_dirname(mrb_state *mrb, mrb_value klass)
{
#if defined(_WIN32) || defined(_WIN64)
char dname[_MAX_DIR], vname[_MAX_DRIVE];
char buffer[_MAX_DRIVE + _MAX_DIR];
char *path;
size_t ridx;
mrb_value s;
mrb_get_args(mrb, "S", &s);
path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
_splitpath((const char*)path, vname, dname, NULL, NULL);
snprintf(buffer, _MAX_DRIVE + _MAX_DIR, "%s%s", vname, dname);
mrb_locale_free(path);
ridx = strlen(buffer);
if (ridx == 0) {
strncpy(buffer, ".", 2); /* null terminated */
} else if (ridx > 1) {
ridx--;
while (ridx > 0 && (buffer[ridx] == '/' || buffer[ridx] == '\\')) {
buffer[ridx] = '\0'; /* remove last char */
ridx--;
}
}
return mrb_str_new_cstr(mrb, buffer);
#else
char *dname, *path;
mrb_value s;
mrb_get_args(mrb, "S", &s);
path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
if ((dname = dirname(path)) == NULL) {
mrb_locale_free(path);
mrb_sys_fail(mrb, "dirname");
}
mrb_locale_free(path);
return mrb_str_new_cstr(mrb, dname);
#endif
}
/*
* call-seq:
* Signal.signame(signo) -> string or nil
*
* Convert signal number to signal name.
* Returns +nil+ if the signo is an invalid signal number.
*
* Signal.trap("INT") { |signo| puts Signal.signame(signo) }
* Process.kill("INT", 0)
*
* <em>produces:</em>
*
* INT
*/
static mrb_value
signal_signame(mrb_state *mrb, mrb_value mod)
{
mrb_int signo;
const char *signame;
mrb_get_args(mrb, "i", &signo);
signame = signo2signm(signo);
if (signame)
return mrb_str_new_cstr(mrb, signame);
else
return mrb_nil_value();
}
void
test_add_gray_list(void)
{
mrb_state *mrb = mrb_open();
struct RBasic *obj1, *obj2;
puts("test_add_gray_list");
change_gen_gc_mode(mrb, FALSE);
gc_assert(mrb->gray_list == NULL);
obj1 = mrb_basic_ptr(mrb_str_new_cstr(mrb, "test"));
add_gray_list(mrb, obj1);
gc_assert(mrb->gray_list == obj1);
gc_assert(is_gray(obj1));
obj2 = mrb_basic_ptr(mrb_str_new_cstr(mrb, "test"));
add_gray_list(mrb, obj2);
gc_assert(mrb->gray_list == obj2);
gc_assert(mrb->gray_list->gcnext == obj1);
gc_assert(is_gray(obj2));
mrb_close(mrb);
}
static mrb_value
mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
{
mrb_value v;
if (mrb_fixnum_p(val)) return val;
v = convert_type(mrb, val, "Integer", method, TRUE);
if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) {
mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S to Integer (%S#%S gives %S)",
val, val, mrb_str_new_cstr(mrb, method), v);
}
return v;
}
mrb_value ccvaluemap_to_rubyval(mrb_state* mrb, const cocos2d::ValueMap& inValue)
{
mrb_value rhash = mrb_hash_new(mrb);
for (auto iter = inValue.begin(); iter != inValue.end(); ++iter) {
std::string key = iter->first;
const Value& obj = iter->second;
mrb_value hkey = mrb_str_new_cstr(mrb, key.c_str());
mrb_value hval = ccvalue_to_rubyval(mrb, obj);
mrb_hash_set(mrb, rhash, hkey, hval);
}
return rhash;
}
static mrb_value
sym_inspect(mrb_state *mrb, mrb_value sym)
{
#ifdef INCLUDE_ENCODING
#define STR_ENC_GET(mrb, str) mrb_enc_from_index(mrb, ENCODING_GET(mrb, str))
mrb_value str;
mrb_sym id = SYM2ID(sym);
mrb_encoding *enc;
const char *ptr;
long len;
char *dest;
mrb_encoding *resenc = mrb_default_internal_encoding(mrb);
if (resenc == NULL) resenc = mrb_default_external_encoding(mrb);
sym = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id));//mrb_id2str(id);
enc = STR_ENC_GET(mrb, sym);
ptr = RSTRING_PTR(sym);
len = RSTRING_LEN(sym);
if ((resenc != enc && !mrb_str_is_ascii_only_p(mrb, sym)) || len != (long)strlen(ptr) ||
!mrb_enc_symname_p(ptr, enc) || !sym_printable(mrb, ptr, ptr + len, enc)) {
str = mrb_str_inspect(mrb, sym);
len = RSTRING_LEN(str);
mrb_str_resize(mrb, str, len + 1);
dest = RSTRING_PTR(str);
memmove(dest + 1, dest, len);
dest[0] = ':';
}
else {
char *dest;
str = mrb_enc_str_new(mrb, 0, len + 1, enc);
dest = RSTRING_PTR(str);
dest[0] = ':';
memcpy(dest + 1, ptr, len);
}
return str;
#else
mrb_value str;
const char *name;
mrb_sym id = SYM2ID(sym);
name = mrb_sym2name(mrb, id); //mrb_id2name(id);
str = mrb_str_new(mrb, 0, strlen(name)+1);
RSTRING(str)->buf[0] = ':';
strcpy(RSTRING(str)->buf+1, name);
if (!mrb_symname_p(name)) {
str = mrb_str_dump(mrb, str);
strncpy(RSTRING(str)->buf, ":\"", 2);
}
return str;
#endif
}
mrb_value
mrb_io_sysread(mrb_state *mrb, mrb_value io)
{
struct mrb_io *fptr;
mrb_value buf = mrb_nil_value();
mrb_int maxlen;
int ret;
mrb_get_args(mrb, "i|S", &maxlen, &buf);
if (maxlen < 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "negative expanding string size");
}
else if (maxlen == 0) {
return mrb_str_new(mrb, NULL, maxlen);
}
if (mrb_nil_p(buf)) {
buf = mrb_str_new(mrb, NULL, maxlen);
}
if (RSTRING_LEN(buf) != maxlen) {
buf = mrb_str_resize(mrb, buf, maxlen);
} else {
mrb_str_modify(mrb, RSTRING(buf));
}
fptr = (struct mrb_io *)io_get_open_fptr(mrb, io);
if (!fptr->readable) {
mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
}
ret = read(fptr->fd, RSTRING_PTR(buf), (fsize_t)maxlen);
switch (ret) {
case 0: /* EOF */
if (maxlen == 0) {
buf = mrb_str_new_cstr(mrb, "");
} else {
mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
}
break;
case -1: /* Error */
mrb_sys_fail(mrb, "sysread failed");
break;
default:
if (RSTRING_LEN(buf) != ret) {
buf = mrb_str_resize(mrb, buf, ret);
}
break;
}
return buf;
}
mrb_value
mrb_io_initialize(mrb_state *mrb, mrb_value io)
{
struct mrb_io *fptr;
mrb_int fd;
mrb_value mode, opt;
int flags;
mode = opt = mrb_nil_value();
mrb_get_args(mrb, "i|So", &fd, &mode, &opt);
if (mrb_nil_p(mode)) {
mode = mrb_str_new_cstr(mrb, "r");
}
if (mrb_nil_p(opt)) {
opt = mrb_hash_new(mrb);
}
flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
fptr = DATA_PTR(io);
if (fptr != NULL) {
fptr_finalize(mrb, fptr, 0);
mrb_free(mrb, fptr);
}
fptr = mrb_io_alloc(mrb);
DATA_TYPE(io) = &mrb_io_type;
DATA_PTR(io) = fptr;
fptr->fd = fd;
fptr->writable = ((flags & FMODE_WRITABLE) != 0);
fptr->sync = 0;
return io;
}
void
mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
{
const struct types *type = builtin_types;
struct RString *s;
enum mrb_vtype xt;
xt = mrb_type(x);
if ((xt != t) || (xt == MRB_TT_DATA)) {
while (type->type < MRB_TT_MAXDEFINE) {
if (type->type == t) {
const char *etype;
if (mrb_nil_p(x)) {
etype = "nil";
}
else if (mrb_fixnum_p(x)) {
etype = "Fixnum";
}
else if (mrb_type(x) == MRB_TT_SYMBOL) {
etype = "Symbol";
}
else if (mrb_special_const_p(x)) {
s = mrb_str_ptr(mrb_obj_as_string(mrb, x));
etype = s->ptr;
}
else {
etype = mrb_obj_classname(mrb, x);
}
mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %S (expected %S)",
mrb_str_new_cstr(mrb, etype), mrb_str_new_cstr(mrb, type->name));
}
type++;
}
mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %S (%S given)",
mrb_fixnum_value(t), mrb_fixnum_value(mrb_type(x)));
}
}
mrb_value
mrb_file__getwd(mrb_state *mrb, mrb_value klass)
{
mrb_value path;
char buf[MAXPATHLEN], *utf8;
if (GETCWD(buf, MAXPATHLEN) == NULL) {
mrb_sys_fail(mrb, "getcwd(2)");
}
utf8 = mrb_utf8_from_locale(buf, -1);
path = mrb_str_new_cstr(mrb, utf8);
mrb_utf8_free(utf8);
return path;
}
static void
load_mrb_file(mrb_state *mrb, mrb_value filepath)
{
char *fpath = RSTRING_PTR(filepath);
int arena_idx;
FILE *fp;
mrb_irep *irep;
{
FILE *fp = fopen(fpath, "rb");
if (fp == NULL) {
mrb_load_fail(
mrb,
mrb_str_new_cstr(mrb, fpath),
"cannot load such file"
);
return;
}
fclose(fp);
}
arena_idx = mrb_gc_arena_save(mrb);
fp = fopen(fpath, "rb");
irep = mrb_read_irep_file(mrb, fp);
fclose(fp);
mrb_gc_arena_restore(mrb, arena_idx);
if (irep) {
struct RProc *proc;
/*
size_t i;
for (i = sirep; i < mrb->irep_len; i++) {
mrb->irep[i]->filename = mrb_string_value_ptr(mrb, filepath);
}
*/
replace_stop_with_return(mrb, irep);
proc = mrb_proc_new(mrb, irep);
proc->target_class = mrb->object_class;
arena_idx = mrb_gc_arena_save(mrb);
mrb_yield_with_class(mrb, mrb_obj_value(proc), 0, NULL, mrb_top_self(mrb), mrb->object_class);
mrb_gc_arena_restore(mrb, arena_idx);
} else if (mrb->exc) {
// fail to load
longjmp(*(jmp_buf*)mrb->jmp, 1);
}
}
// from native
mrb_value array_to_rubyval(mrb_state* mrb, __Array* inValue)
{
mrb_value rarr = mrb_ary_new(mrb);
Ref* obj = nullptr;
std::string className = "";
__String* strVal = nullptr;
__Dictionary* dictVal = nullptr;
__Array* arrVal = nullptr;
__Double* doubleVal = nullptr;
__Bool* boolVal = nullptr;
__Float* floatVal = nullptr;
__Integer* intVal = nullptr;
CCARRAY_FOREACH(inValue, obj)
{
if (nullptr == obj)
continue;
mrb_value rval;
std::string typeName = typeid(*obj).name();
auto iter = g_rubyType.find(typeName);
if (g_rubyType.end() != iter) {
className = iter->second;
if (nullptr != dynamic_cast<Ref*>(obj)) {
rval = to_mrb_value(mrb, obj);
}
} else if((strVal = dynamic_cast<__String *>(obj))) {
rval = mrb_str_new_cstr(mrb, strVal->getCString());
} else if ((dictVal = dynamic_cast<__Dictionary*>(obj))) {
rval = dictionary_to_rubyval(mrb, dictVal);
} else if ((arrVal = dynamic_cast<__Array*>(obj))) {
rval = array_to_rubyval(mrb, arrVal);
} else if ((doubleVal = dynamic_cast<__Double*>(obj))) {
rval = mrb_float_value(mrb, (mrb_float)doubleVal->getValue());
} else if ((floatVal = dynamic_cast<__Float*>(obj))) {
rval = mrb_float_value(mrb, (mrb_float)floatVal->getValue());
} else if ((intVal = dynamic_cast<__Integer*>(obj))) {
rval = mrb_fixnum_value((mrb_int)intVal->getValue());
} else if ((boolVal = dynamic_cast<__Bool*>(obj))) {
rval = mrb_bool_value((mrb_bool)boolVal->getValue());
} else {
CCASSERT(false, "the type isn't suppored.");
}
mrb_ary_push(mrb, rarr, rval);
}
return rarr;
}
static mrb_value
mrb_http_object_message_get(mrb_state *mrb, mrb_value self)
{
const char* message = NULL;
switch(mrb_fixnum(OBJECT_GET(mrb, self, "status_code"))) {
case 100: message = "Continue"; break;
case 101: message = "Switching Protocols"; break;
case 200: message = "OK"; break;
case 201: message = "Created"; break;
case 202: message = "Accepted"; break;
case 203: message = "Non-Authoritative Information"; break;
case 204: message = "No Content"; break;
case 205: message = "Reset Content"; break;
case 206: message = "Partial Content"; break;
case 300: message = "Multiple Choices"; break;
case 301: message = "Moved Permanently"; break;
case 302: message = "Found"; break;
case 303: message = "See Other"; break;
case 304: message = "Not Modified"; break;
case 305: message = "Use Proxy"; break;
//case 306: message = "(reserved)"; break;
case 307: message = "Temporary Redirect"; break;
case 400: message = "Bad Request"; break;
case 401: message = "Unauthorized"; break;
case 402: message = "Payment Required"; break;
case 403: message = "Forbidden"; break;
case 404: message = "Not Found"; break;
case 405: message = "Method Not Allowed"; break;
case 406: message = "Not Acceptable"; break;
case 407: message = "Proxy Authentication Required"; break;
case 408: message = "Request Timeout"; break;
case 409: message = "Conflict"; break;
case 410: message = "Gone"; break;
case 411: message = "Length Required"; break;
case 412: message = "Precondition Failed"; break;
case 413: message = "Request Entity Too Large"; break;
case 414: message = "Request-URI Too Long"; break;
case 415: message = "Unsupported Media Type"; break;
case 416: message = "Requested Range Not Satisfiable"; break;
case 417: message = "Expectation Failed"; break;
case 500: message = "Internal Server Error"; break;
case 501: message = "Not Implemented"; break;
case 502: message = "Bad Gateway"; break;
case 503: message = "Service Unavailable"; break;
case 504: message = "Gateway Timeout"; break;
case 505: message = "HTTP Version Not Supported"; break;
default: mrb_raise(mrb, E_RUNTIME_ERROR, "Not supported status code.");
}
return mrb_str_new_cstr(mrb, message);
}
static int
mrb_io_modestr_to_flags(mrb_state *mrb, const char *mode)
{
int flags = 0;
const char *m = mode;
switch (*m++) {
case 'r':
flags |= FMODE_READABLE;
break;
case 'w':
flags |= FMODE_WRITABLE | FMODE_CREATE | FMODE_TRUNC;
break;
case 'a':
flags |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE;
break;
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
}
while (*m) {
switch (*m++) {
case 'b':
flags |= FMODE_BINMODE;
break;
case '+':
flags |= FMODE_READWRITE;
break;
case ':':
/* XXX: PASSTHROUGH*/
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
}
}
return flags;
}
static mrb_value
mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
{
if (mrb_type(klass) == MRB_TT_SCLASS) {
mrb_value s = mrb_str_new(mrb, "#<", 2);
mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__"));
mrb_str_cat2(mrb, s, "Class:");
switch (mrb_type(v)) {
case MRB_TT_CLASS:
case MRB_TT_MODULE:
case MRB_TT_SCLASS:
mrb_str_append(mrb, s, mrb_inspect(mrb, v));
break;
default:
mrb_str_append(mrb, s, mrb_any_to_s(mrb, v));
break;
}
mrb_str_cat2(mrb, s, ">");
return s;
}
else {
struct RClass *c = mrb_class_ptr(klass);
const char *cn = mrb_class_name(mrb, c);
if (!cn) {
char buf[256];
int n = 0;
switch (mrb_type(klass)) {
case MRB_TT_CLASS:
n = snprintf(buf, sizeof(buf), "#<Class:%p>", c);
break;
case MRB_TT_MODULE:
n = snprintf(buf, sizeof(buf), "#<Module:%p>", c);
break;
default:
break;
}
return mrb_str_dup(mrb, mrb_str_new(mrb, buf, n));
}
else {
return mrb_str_dup(mrb, mrb_str_new_cstr(mrb, cn));
}
}
}
static mrb_value
mrb_uefi_pointer_inspect(mrb_state *mrb, mrb_value self)
{
char buf[32];
VOID *ptr = mrb_uefi_pointer_raw_value(mrb, self);
#if defined(MDE_CPU_X64)
snprintf(buf, sizeof(buf), "<Pointer 0x%016llX>", (UINTN)ptr);
#elif defined(MDE_CPU_IA32)
snprintf(buf, sizeof(buf), "<Pointer 0x%08lX>", (UINTN)ptr);
#else
#error Not Supported
#endif
return mrb_str_new_cstr(mrb, buf);
}
static mrb_value
exc_to_s(mrb_state *mrb, mrb_value exc)
{
mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
struct RObject *p;
if (!mrb_string_p(mesg)) {
return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc));
}
p = mrb_obj_ptr(mesg);
if (!p->c) {
p->c = mrb->string_class;
}
return mesg;
}
mrb_value
mrb_class_path(mrb_state *mrb, struct RClass *c)
{
mrb_value path;
path = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"));
if (mrb_nil_p(path)) {
struct RClass *outer = mrb_class_outer_module(mrb, c);
mrb_sym sym = class_sym(mrb, c, outer);
if (outer && outer != mrb->object_class) {
mrb_value base = mrb_class_path(mrb, outer);
path = mrb_str_plus(mrb, base, mrb_str_new_cstr(mrb, "::"));
mrb_str_concat(mrb, path, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym)));
}
else if (sym == 0) {
return mrb_nil_value();
}
else {
path = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym));
}
mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"), path);
}
return path;
}
/*
* 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;
int argcnt;
long i;
mrb_value b, st;
mrb_sym id;
mrb_value *argv;
int argc;
name = mrb_nil_value();
rest = mrb_nil_value();
mrb_get_args(mrb, "&*", &b, &argv, &argc);
if (argc > 0) name = argv[0];
if (argc > 1) rest = argv[1];
//mrb_scan_args(argc, argv, "1*", &name, &rest);
if (mrb_type(rest) == MRB_TT_ARRAY) {
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
}
for (i=0; i<RARRAY_LEN(rest); i++) {
id = mrb_to_id(mrb, RARRAY_PTR(rest)[i]);
RARRAY_PTR(rest)[i] = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id));
}
}
else {
pargv = &argv[1];
argcnt = argc-1;
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
//mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
pargv = &argv[0];
argcnt++;
}
rest = mrb_ary_new_from_values(mrb, pargv, argcnt);
}
st = make_struct(mrb, name, rest, struct_class(mrb));
if (!mrb_nil_p(b)) {
mrb_funcall(mrb, b, "call", 1, &st);
}
return st;
}
static mrb_value
pcre_regexp_match(mrb_state *mrb, mrb_value self) {
const char *str;
char global_match[3];
mrb_value regexp;
struct mrb_pcre_regexp *reg;
int i;
mrb_value mrb_i, mrb_match;
size_t nmatch = 999;
int match[999];
int regno;
int ai;
struct RClass* clazz;
mrb_value c;
mrb_value args[2];
mrb_get_args(mrb, "z", &str);
regexp = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@regexp"));
Data_Get_Struct(mrb, regexp, &mrb_pcre_regexp_type, reg);
regno = pcre_exec(reg->re, NULL, str, strlen(str), 0, 0, match, nmatch);
if (regno < 0)
return mrb_nil_value();
mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), mrb_nil_value());
ai = mrb_gc_arena_save(mrb);
clazz = mrb_class_get(mrb, "PcreMatchData");
c = mrb_obj_new(mrb, clazz, 0, NULL);
mrb_iv_set(mrb, c,mrb_intern_lit(mrb, "@string"), mrb_str_new_cstr(mrb, str));
for (i = 0; i < regno; i++) {
args[0] = mrb_fixnum_value(match[i * 2]);
args[1] = mrb_fixnum_value(match[i * 2 + 1] - match[i * 2]);
mrb_funcall_argv(mrb, c, mrb_intern_lit(mrb, "push"), sizeof(args)/sizeof(args[0]), &args[0]);
if (i > 0 && i < 10) {
sprintf(global_match, "$%i", i);
mrb_i = mrb_fixnum_value(i);
mrb_match = mrb_funcall_argv(mrb, c, mrb_intern_lit(mrb, "[]"), 1, &mrb_i);
mrb_gv_set(mrb, mrb_intern_cstr(mrb, global_match), mrb_match);
}
mrb_gc_arena_restore(mrb, ai);
}
mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), c);
return c;
}
static void
load_mrb_file(mrb_state *mrb, mrb_value filepath)
{
char *fpath = RSTRING_PTR(filepath);
int ai;
FILE *fp;
mrb_irep *irep;
fp = fopen(fpath, "rb");
if (fp == NULL) {
mrb_load_fail(
mrb,
mrb_str_new_cstr(mrb, fpath),
"cannot load such file"
);
return;
}
ai = mrb_gc_arena_save(mrb);
irep = mrb_read_irep_file(mrb, fp);
fclose(fp);
mrb_gc_arena_restore(mrb, ai);
if (irep) {
struct RProc *proc;
/*
size_t i;
for (i = sirep; i < mrb->irep_len; i++) {
mrb->irep[i]->filename = mrb_string_value_ptr(mrb, filepath);
}
*/
#ifdef USE_MRUBY_OLD_BYTE_CODE
replace_stop_with_return(mrb, irep);
#endif
proc = mrb_proc_new(mrb, irep);
MRB_PROC_SET_TARGET_CLASS(proc, mrb->object_class);
ai = mrb_gc_arena_save(mrb);
mrb_yield_with_class(mrb, mrb_obj_value(proc), 0, NULL, mrb_top_self(mrb), mrb->object_class);
mrb_gc_arena_restore(mrb, ai);
} else if (mrb->exc) {
// fail to load
longjmp(*(jmp_buf*)mrb->jmp, 1);
}
}
static mrb_value
inspect_struct(mrb_state *mrb, mrb_value s, int recur)
{
const char *cn = mrb_class_name(mrb, mrb_obj_class(mrb, s));
mrb_value members, str = mrb_str_new_lit(mrb, "#<struct ");
mrb_value *ptr, *ptr_members;
mrb_int i, len;
if (cn) {
mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, cn));
}
if (recur) {
return mrb_str_cat_lit(mrb, str, ":...>");
}
members = mrb_struct_members(mrb, s);
ptr_members = RARRAY_PTR(members);
ptr = RSTRUCT_PTR(s);
len = RSTRUCT_LEN(s);
for (i=0; i<len; i++) {
mrb_value slot;
mrb_sym id;
if (i > 0) {
mrb_str_cat_lit(mrb, str, ", ");
}
else if (cn) {
mrb_str_cat_lit(mrb, str, " ");
}
slot = ptr_members[i];
id = mrb_symbol(slot);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
const char *name;
mrb_int len;
name = mrb_sym2name_len(mrb, id, &len);
mrb_str_append(mrb, str, mrb_str_new(mrb, name, len));
}
else {
mrb_str_append(mrb, str, mrb_inspect(mrb, slot));
}
mrb_str_cat_lit(mrb, str, "=");
mrb_str_append(mrb, str, mrb_inspect(mrb, ptr[i]));
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
mrb_value mrb_serialport_read_char(mrb_state *mrb, mrb_value self) {
char ch[1];
ssize_t len = 0;
int fd = mrb_fixnum(IV_GET("@fd"));
len = read(fd, ch, sizeof(char));
if ( len == 0 ) {
return mrb_nil_value();
}
else if ( len < 0 ) {
if ( errno == EAGAIN )
return mrb_nil_value();
update_error(mrb, self);
mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno));
}
return mrb_str_new_cstr(mrb, ch);
}
static mrb_value
config_get_value(mrb_state *mrb, mrb_value self)
{
ALLEGRO_CONFIG *cfg;
char *section;
char *key;
const char *value;
Check_Destroyed(mrb, self, config, cfg);
mrb_get_args(mrb, "zz", §ion, &key);
value = al_get_config_value(cfg, section, key);
if (!value) {
mrb_raise(mrb, E_ALLEGRO_ERROR, "section or key do not exist");
}
return mrb_str_new_cstr(mrb, value);
}
