static mrb_value
mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
{
mrb_value id;
mrb_bool method_defined_p;
id = get_sym_or_str_arg(mrb);
if (mrb_symbol_p(id)) {
method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(id));
} else {
mrb_value sym = mrb_check_intern_str(mrb, id);
if (mrb_nil_p(sym)) {
method_defined_p = FALSE;
}
else {
method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(sym));
}
}
return mrb_bool_value(method_defined_p);
}
mrb_sym
mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
{
mrb_value name;
name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern2(mrb, "__classid__", 11));
if (mrb_nil_p(name)) {
if (!outer) return 0;
else {
struct csym_arg arg;
arg.c = c;
arg.sym = 0;
iv_foreach(mrb, outer->iv, csym_i, &arg);
return arg.sym;
}
}
return mrb_symbol(name);
}
static mrb_value
mrb_http_request_port(mrb_state *mrb, mrb_value self)
{
mrb_value value_context;
mrb_http_parser_context* context;
value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "parser_context"));
Data_Get_Struct(mrb, value_context, &http_parser_context_type, context);
if (!context) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
if (context->handle.field_set & (1<<UF_PORT)) {
return mrb_fixnum_value(context->handle.port);
}
mrb_value schema = mrb_http_request_schema(mrb, self);
if (!mrb_nil_p(schema) && !strncmp("https", (char*) RSTRING_PTR(schema), RSTRING_LEN(schema))) {
return mrb_fixnum_value(443);
}
return mrb_fixnum_value(80);
}
/*
* call-seq:
* obj.inspect -> string
*
* Returns a string containing a human-readable representation of
* <i>obj</i>. If not overridden and no instance variables, uses the
* <code>to_s</code> method to generate the string.
* <i>obj</i>. If not overridden, uses the <code>to_s</code> method to
* generate the string.
*
* [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]"
* Time.new.inspect #=> "2008-03-08 19:43:39 +0900"
*/
mrb_value
mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
{
if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) {
long len = ROBJECT_NUMIV(obj);
if (len > 0) {
mrb_value str;
const char *c = mrb_obj_classname(mrb, obj);
str = mrb_sprintf(mrb, "-<%s:%p", c, (void*)&obj);
return inspect_obj(mrb, obj, str, 0);
}
return mrb_any_to_s(mrb, obj);
}
else if (mrb_nil_p(obj)) {
return mrb_str_new_cstr(mrb, "nil");
}
return mrb_funcall(mrb, obj, "to_s", 0, 0);
}
static int
parser_settings_on_header_field(http_parser* parser, const char* at, size_t len)
{
mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data;
mrb_state* mrb = context->mrb;
int ai = mrb_gc_arena_save(mrb);
if (context->was_header_value) {
if (!mrb_nil_p(OBJECT_GET(mrb, context->instance, "last_header_field"))) {
mrb_str_concat(mrb, OBJECT_GET(mrb, context->instance, "last_header_field"), OBJECT_GET(mrb, context->instance, "last_header_value"));
OBJECT_SET(mrb, context->instance, "last_header_value", mrb_nil_value());
}
OBJECT_SET(mrb, context->instance, "last_header_field", mrb_str_new(mrb, at, len));
context->was_header_value = FALSE;
} else {
mrb_str_concat(mrb, OBJECT_GET(mrb, context->instance, "last_header_field"), mrb_str_new(mrb, at, len));
}
mrb_gc_arena_restore(mrb, ai);
return 0;
}
MRB_API mrb_value
mrb_Float(mrb_state *mrb, mrb_value val)
{
if (mrb_nil_p(val)) {
mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float");
}
switch (mrb_type(val)) {
case MRB_TT_FIXNUM:
return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val));
case MRB_TT_FLOAT:
return val;
case MRB_TT_STRING:
return mrb_float_value(mrb, mrb_str_to_dbl(mrb, val, TRUE));
default:
return mrb_convert_type(mrb, val, MRB_TT_FLOAT, "Float", "to_f");
}
}
MRB_API mrb_value
mrb_ary_splat(mrb_state *mrb, mrb_value v)
{
mrb_value a;
if (mrb_array_p(v)) {
return v;
}
if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
return mrb_ary_new_from_values(mrb, 1, &v);
}
a = mrb_funcall(mrb, v, "to_a", 0);
if (mrb_nil_p(a)) {
return mrb_ary_new_from_values(mrb, 1, &v);
}
mrb_ensure_array_type(mrb, a);
return a;
}
static void
range_check(mrb_state *mrb, mrb_value a, mrb_value b)
{
mrb_value ans;
int ta;
int tb;
ta = mrb_type(a);
tb = mrb_type(b);
if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) &&
(tb == MRB_TT_FIXNUM || tb == MRB_TT_FLOAT)) {
return;
}
ans = mrb_funcall(mrb, a, "<=>", 1, b);
if (mrb_nil_p(ans)) {
/* can not be compared */
mrb_raise(mrb, E_ARGUMENT_ERROR, "bad value for range");
}
}
static mrb_value
mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)
{
mrb_int idx;
regexp_check(mrb, indx);
switch (mrb_type(indx)) {
case MRB_TT_FIXNUM:
idx = mrb_fixnum(indx);
num_index:
str = str_substr(mrb, str, idx, 1);
if (!mrb_nil_p(str) && RSTRING_LEN(str) == 0) return mrb_nil_value();
return str;
case MRB_TT_STRING:
if (str_index(mrb, str, indx, 0) != -1)
return mrb_str_dup(mrb, indx);
return mrb_nil_value();
case MRB_TT_RANGE:
/* check if indx is Range */
{
mrb_int beg, len;
mrb_value tmp;
len = RSTRING_LEN_UTF8(str);
if (mrb_range_beg_len(mrb, indx, &beg, &len, len)) {
tmp = str_subseq(mrb, str, beg, len);
return tmp;
}
else {
return mrb_nil_value();
}
}
default:
idx = mrb_fixnum(indx);
goto num_index;
}
return mrb_nil_value(); /* not reached */
}
static int
parser_settings_on_message_complete(http_parser* parser)
{
mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data;
mrb_state* mrb = context->mrb;
mrb_value c = context->instance;
if (context->handle.field_set & (1<<UF_SCHEMA)) {
OBJECT_SET(mrb, c, "schema", mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_SCHEMA].off, context->handle.field_data[UF_SCHEMA].len));
}
if (context->handle.field_set & (1<<UF_HOST)) {
OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_HOST].off, context->handle.field_data[UF_HOST].len));
}
if (context->handle.field_set & (1<<UF_HOST)) {
OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_HOST].off, context->handle.field_data[UF_HOST].len));
}
if (context->handle.field_set & (1<<UF_PORT)) {
OBJECT_SET(mrb, c, "port", mrb_fixnum_value(context->handle.port));
} else {
if (context->handle.field_set & (1<<UF_SCHEMA)) {
mrb_value schema = mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_SCHEMA].off, context->handle.field_data[UF_SCHEMA].len);
if (!mrb_nil_p(schema) && !strcmp("https", (char*) RSTRING_PTR(schema))) {
OBJECT_SET(mrb, c, "port", mrb_fixnum_value(443));
}
}
}
if (context->handle.field_set & (1<<UF_PATH)) {
OBJECT_SET(mrb, c, "path", mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_PATH].off, context->handle.field_data[UF_PATH].len));
}
if (context->handle.field_set & (1<<UF_QUERY)) {
OBJECT_SET(mrb, c, "query", mrb_str_substr(mrb, OBJECT_GET(mrb, c, "buf"), context->handle.field_data[UF_QUERY].off, context->handle.field_data[UF_QUERY].len));
}
OBJECT_SET(mrb, c, "method", mrb_str_new_cstr(mrb, http_method_str(context->parser.method)));
OBJECT_SET(mrb, c, "status_code", mrb_fixnum_value(context->parser.status_code));
OBJECT_SET(mrb, c, "content_length", mrb_fixnum_value(context->parser.content_length));
OBJECT_REMOVE(mrb, c, "last_header_field");
OBJECT_REMOVE(mrb, c, "last_header_value");
OBJECT_REMOVE(mrb, c, "buf");
return 0;
}
static mrb_value
bs_locate_handle_buffer(mrb_state *mrb, mrb_value self)
{
mrb_value guid;
mrb_value ret;
UINTN size;
EFI_HANDLE *phandles;
mrb_get_args(mrb, "o", &guid);
if (mrb_nil_p(guid)){
/* AllHandles */
EFI_STATUS status;
status = gBS->LocateHandleBuffer(AllHandles, NULL, NULL, &size, &phandles);
if (EFI_ERROR(status)){
return mrb_nil_value();
}
}else{
/* ByProtocol */
EFI_STATUS status;
EFI_GUID efi_guid;
mrb_uefi_guid_get_guid(mrb, guid, &efi_guid);
status = gBS->LocateHandleBuffer(ByProtocol, &efi_guid, NULL, &size, &phandles);
if (EFI_ERROR(status)){
return mrb_nil_value();
}
}
ret = mrb_ary_new_capa(mrb, (int)size);
{
UINTN i;
for (i=0; i<size; i++){
int arena = mrb_gc_arena_save(mrb);
mrb_ary_push(mrb, ret, mrb_uefi_handle_make(mrb, phandles[i]));
mrb_gc_arena_restore(mrb, arena);
}
}
gBS->FreePool(phandles);
return ret;
}
static mrb_value
method_parameters(mrb_state *mrb, mrb_value self)
{
mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
struct RProc *rproc;
struct RClass *orig;
mrb_value ret;
if (mrb_nil_p(proc)) {
mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest"));
mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest);
return mrb_ary_new_from_values(mrb, 1, &arest);
}
rproc = mrb_proc_ptr(proc);
orig = rproc->c;
rproc->c = mrb->proc_class;
ret = mrb_funcall(mrb, proc, "parameters", 0);
rproc->c = orig;
return ret;
}
// FLTK::NativeFileChooser#filename(index=nil)
// Return the filename the user choose. If index is given, return one of the filenames the user selected.
mrb_value mrb_fltk_native_file_chooser_filename_instance_method( mrb_state *mrb, mrb_value self ) {
// TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO
// Segfaults! Wowza
// TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO
GET_DATA( fl_native_file_chooser, Fl_Native_File_Chooser, self );
mrb_value mrb_index;
mrb_get_args( mrb, "|i", &mrb_index );
mrb_value mrb_filename;
if( mrb_nil_p( mrb_index ) ) {
mrb_filename = mrb_str_new_cstr( mrb, fl_native_file_chooser->filename() );
} else {
mrb_filename = mrb_str_new_cstr( mrb, fl_native_file_chooser->filename( mrb_fixnum( mrb_index ) ) );
}
printf( "-==--==--==-=-=-=-=-=-=-=-=--=-=-=----------\n" );
mrb_p( mrb, mrb_filename );
printf( "-==--==--==-=-=-=-=-=-=-=-=--=-=-=----------\n" );
return mrb_filename;
}
static mrb_value
mrb_random_srand(mrb_state *mrb, mrb_value self)
{
mrb_value seed;
mrb_value old_seed;
mt_state *t = DATA_GET_PTR(mrb, self, &mt_state_type, mt_state);
seed = get_opt(mrb);
seed = mrb_random_mt_srand(mrb, t, seed);
old_seed = t->has_seed? mrb_fixnum_value(t->seed) : mrb_nil_value();
if (mrb_nil_p(seed)) {
t->has_seed = FALSE;
}
else {
mrb_assert(mrb_fixnum_p(seed));
t->has_seed = TRUE;
t->seed = mrb_fixnum(seed);
}
return old_seed;
}
mrb_value
mrb_UV_Shutdown_set_handle(mrb_state* mrb, mrb_value self) {
uv_shutdown_t * native_self = mruby_unbox_uv_shutdown_t(self);
mrb_value handle;
mrb_get_args(mrb, "o", &handle);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, handle, Stream_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "Stream expected");
return mrb_nil_value();
}
uv_stream_t * native_handle = (mrb_nil_p(handle) ? NULL : mruby_unbox_uv_stream_t(handle));
native_self->handle = native_handle;
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}
mrb_value
mrb_UV_Getnameinfo_set_loop(mrb_state* mrb, mrb_value self) {
uv_getnameinfo_t * native_self = mruby_unbox_uv_getnameinfo_t(self);
mrb_value loop;
mrb_get_args(mrb, "o", &loop);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, loop, Loop_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "Loop expected");
return mrb_nil_value();
}
uv_loop_t * native_loop = (mrb_nil_p(loop) ? NULL : mruby_unbox_uv_loop_t(loop));
native_self->loop = native_loop;
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}
static mrb_value
mrb_http_parser_parse(mrb_state *mrb, mrb_value self)
{
mrb_value arg_data;
mrb_value value_context;
mrb_http_parser_context* context;
struct RProc *b = NULL;
value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "parser_context"));
Data_Get_Struct(mrb, value_context, &http_parser_context_type, context);
if (!context) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
mrb_get_args(mrb, "bo", &b, &arg_data);
if (mrb_nil_p(arg_data)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
mrb_iv_set(mrb, self, mrb_intern(mrb, "complete_cb"), b ? mrb_obj_value(b) : mrb_nil_value());
context->parser.data = context;
context->was_header_value = TRUE;
CTXV_SET(context, "headers", mrb_hash_new(mrb, 32));
http_parser_init(&context->parser, HTTP_REQUEST);
context->settings.on_url = parser_settings_on_url;
context->settings.on_header_field = parser_settings_on_header_field;
context->settings.on_header_value = parser_settings_on_header_value;
context->settings.on_headers_complete = parser_settings_on_headers_complete;
if (b) {
context->settings.on_message_complete = parser_settings_on_message_complete;
}
if (RSTRING_LEN(arg_data) > 0) {
http_parser_execute(&context->parser, &context->settings, (char*) RSTRING_PTR(arg_data), RSTRING_CAPA(arg_data));
}
return mrb_nil_value();
}
/* mrb_gc_unregister() removes the object from GC root. */
MRB_API void
mrb_gc_unregister(mrb_state *mrb, mrb_value obj)
{
mrb_sym root = mrb_intern_lit(mrb, GC_ROOT_NAME);
mrb_value table = mrb_gv_get(mrb, root);
struct RArray *a;
mrb_int i, j;
if (mrb_nil_p(table)) return;
if (mrb_type(table) != MRB_TT_ARRAY) {
mrb_gv_set(mrb, root, mrb_nil_value());
return;
}
a = mrb_ary_ptr(table);
mrb_ary_modify(mrb, a);
for (i=j=0; i<a->len; i++) {
if (!mrb_obj_eq(mrb, a->ptr[i], obj)) {
a->ptr[j++] = a->ptr[i];
}
}
a->len = j;
}
// FLTK::Widget#callback
// Gets or sets the current callback function for the widget.
mrb_value mrb_fltk_widget_callback_instance_method( mrb_state *mrb, mrb_value self ) {
GET_DATA( fl_widget, Fl_Widget, self );
mrb_value block = mrb_nil_value();
mrb_get_args( mrb, "&", &block );
if( !mrb_nil_p( block ) ) {
// TODO: Free the existing context struct if it already exists?
mrb_iv_set( mrb, self, mrb_intern_cstr( mrb, "callback" ), block );
mrb_fltk_widget_callback_context *context = (mrb_fltk_widget_callback_context *)malloc( sizeof( mrb_fltk_widget_callback_context ) );
context->mrb = mrb;
context->self = self;
fl_widget->callback( mrb_fltk_widget_callback_function, context );
} else {
block = mrb_iv_get( mrb, self, mrb_intern_cstr( mrb, "callback" ) );
}
return block;
}
static mrb_value
exc_get_backtrace(mrb_state *mrb, mrb_value exc)
{
mrb_sym attr_name;
mrb_value backtrace;
attr_name = mrb_intern_lit(mrb, "backtrace");
backtrace = mrb_iv_get(mrb, exc, attr_name);
if (mrb_nil_p(backtrace)) {
if (mrb_obj_ptr(exc) == mrb->backtrace.exc && mrb->backtrace.n > 0) {
backtrace = mrb_restore_backtrace(mrb);
mrb->backtrace.n = 0;
mrb->backtrace.exc = 0;
}
else {
backtrace = mrb_exc_backtrace(mrb, exc);
}
mrb_iv_set(mrb, exc, attr_name, backtrace);
}
return backtrace;
}
/* set_author
*
* Parameters:
* - value: const git_signature *
*/
mrb_value
mrb_Git_DiffFormatEmailOptions_set_author(mrb_state* mrb, mrb_value self) {
git_diff_format_email_options * native_self = mruby_unbox_git_diff_format_email_options(self);
mrb_value author;
mrb_get_args(mrb, "o", &author);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, author, Signature_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "Signature expected");
return mrb_nil_value();
}
const git_signature * native_author = (mrb_nil_p(author) ? NULL : mruby_unbox_git_signature(author));
native_self->author = native_author;
/* Hacky way to return whatever was passed in. Mirrors typical assignment semantics. */
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}
/* set_id
*
* Parameters:
* - value: const git_oid *
*/
mrb_value
mrb_Git_DiffFormatEmailOptions_set_id(mrb_state* mrb, mrb_value self) {
git_diff_format_email_options * native_self = mruby_unbox_git_diff_format_email_options(self);
mrb_value id;
mrb_get_args(mrb, "o", &id);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, id, Oid_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "Oid expected");
return mrb_nil_value();
}
const git_oid * native_id = (mrb_nil_p(id) ? NULL : mruby_unbox_git_oid(id));
native_self->id = native_id;
/* Hacky way to return whatever was passed in. Mirrors typical assignment semantics. */
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}
mrb_value
convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, int raise)
{
mrb_sym m = 0;
m = mrb_intern(mrb, method);
if (!mrb_respond_to(mrb, val, m)) {
if (raise) {
mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s into %s",
mrb_nil_p(val) ? "nil" :
(mrb_type(val) == MRB_TT_TRUE) ? "true" :
(mrb_type(val) == MRB_TT_FALSE) ? "false" :
mrb_obj_classname(mrb, val),
tname);
return mrb_nil_value();
}
else {
return mrb_nil_value();
}
}
return mrb_funcall(mrb, val, method, 0);
}
static mrb_value
mrb_http_parser_execute(mrb_state *mrb, mrb_value self)
{
mrb_value arg_data;
mrb_value value_context;
mrb_http_parser_context* context;
value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
Data_Get_Struct(mrb, value_context, &http_parser_context_type, context);
if (!context) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
mrb_get_args(mrb, "o", &arg_data);
if (mrb_nil_p(arg_data)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
http_parser_execute(&context->parser, &context->settings, (char*) RSTRING_PTR(arg_data), RSTRING_CAPA(arg_data));
return mrb_nil_value();
}
// FLTK::Group#begin
static mrb_value
mrb_fltk_group_begin_method( mrb_state *mrb, mrb_value self ) {
CONTEXT_SETUP( widget );
mrb_value block = mrb_nil_value();
mrb_get_args( mrb, "&", &block );
if( !mrb_nil_p( block ) ) {
mrb_value args[1];
args[0] = self;
( (Fl_Group *)context->fl_instance )->begin();
mrb_yield_argv( mrb, block, 1, args );
( (Fl_Group *)context->fl_instance )->end();
} else {
( (Fl_Group *)context->fl_instance )->begin();
}
return mrb_nil_value();
}
/* set_backend
*
* Parameters:
* - value: git_odb_backend *
*/
mrb_value
mrb_Git_OdbStream_set_backend(mrb_state* mrb, mrb_value self) {
git_odb_stream * native_self = mruby_unbox_git_odb_stream(self);
mrb_value backend;
mrb_get_args(mrb, "o", &backend);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, backend, OdbBackend_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "OdbBackend expected");
return mrb_nil_value();
}
git_odb_backend * native_backend = (mrb_nil_p(backend) ? NULL : mruby_unbox_git_odb_backend(backend));
native_self->backend = native_backend;
/* Hacky way to return whatever was passed in. Mirrors typical assignment semantics. */
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}
static mrb_value
mrb_grn_table_sort_key_set_key(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_table_sort_key *sort_key;
mrb_value mrb_key;
sort_key = DATA_PTR(self);
mrb_get_args(mrb, "o", &mrb_key);
if (sort_key->key) {
grn_obj_unlink(ctx, sort_key->key);
}
if (mrb_nil_p(mrb_key)) {
sort_key->key = NULL;
} else {
sort_key->key = DATA_PTR(mrb_key);
}
return mrb_nil_value();
}
/*
* call-seq:
* lambda { |...| block } -> a_proc
*
* Equivalent to <code>Proc.new</code>, except the resulting Proc objects
* check the number of parameters passed when called.
*/
static mrb_value
proc_lambda(mrb_state *mrb, mrb_value self)
{
mrb_value blk;
struct RProc *p;
mrb_get_args(mrb, "&", &blk);
if (mrb_nil_p(blk)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
}
if (mrb_type(blk) != MRB_TT_PROC) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc");
}
p = mrb_proc_ptr(blk);
if (!MRB_PROC_STRICT_P(p)) {
struct RProc *p2 = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, p->c);
mrb_proc_copy(p2, p);
p2->flags |= MRB_PROC_STRICT;
return mrb_obj_value(p2);
}
return blk;
}
static mrb_value
mrb_hash_dup(mrb_state *mrb, mrb_value hash)
{
struct RHash* ret;
khash_t(ht) *h, *ret_h;
khiter_t k, ret_k;
mrb_value ifnone, vret;
h = RHASH_TBL(hash);
ret = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
ret->ht = kh_init(ht, mrb);
if (h && kh_size(h) > 0) {
ret_h = ret->ht;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
int ai = mrb_gc_arena_save(mrb);
ret_k = kh_put(ht, mrb, ret_h, KEY(kh_key(h, k)));
mrb_gc_arena_restore(mrb, ai);
kh_val(ret_h, ret_k).v = kh_val(h, k).v;
kh_val(ret_h, ret_k).n = kh_size(ret_h)-1;
}
}
}
if (MRB_RHASH_DEFAULT_P(hash)) {
ret->flags |= MRB_HASH_DEFAULT;
}
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
ret->flags |= MRB_HASH_PROC_DEFAULT;
}
vret = mrb_obj_value(ret);
ifnone = RHASH_IFNONE(hash);
if (!mrb_nil_p(ifnone)) {
mrb_iv_set(mrb, vret, mrb_intern_lit(mrb, "ifnone"), ifnone);
}
return vret;
}
/* set_baseline_index
*
* Parameters:
* - value: git_index *
*/
mrb_value
mrb_Git_CheckoutOptions_set_baseline_index(mrb_state* mrb, mrb_value self) {
git_checkout_options * native_self = mruby_unbox_git_checkout_options(self);
mrb_value baseline_index;
mrb_get_args(mrb, "o", &baseline_index);
/* type checking */
if (!mrb_obj_is_kind_of(mrb, baseline_index, Index_class(mrb))) {
mrb_raise(mrb, E_TYPE_ERROR, "Index expected");
return mrb_nil_value();
}
git_index * native_baseline_index = (mrb_nil_p(baseline_index) ? NULL : mruby_unbox_git_index(baseline_index));
native_self->baseline_index = native_baseline_index;
/* Hacky way to return whatever was passed in. Mirrors typical assignment semantics. */
mrb_value value_as_mrb_value;
mrb_get_args(mrb, "o", &value_as_mrb_value);
return value_as_mrb_value;
}