static mrb_value http_request_method(mrb_state *mrb, mrb_value self) { h2o_mruby_generator_t *generator; struct st_h2o_mruby_http_request_context_t *ctx; const char *arg_url; mrb_int arg_url_len; mrb_value arg_hash; h2o_iovec_t method; h2o_url_t url; /* parse args */ arg_hash = mrb_nil_value(); mrb_get_args(mrb, "s|H", &arg_url, &arg_url_len, &arg_hash); /* precond check */ if ((generator = h2o_mruby_current_generator) == NULL || generator->req == NULL) mrb_exc_raise(mrb, create_downstream_closed_exception(mrb)); /* allocate context and initialize */ ctx = h2o_mem_alloc_shared(&generator->req->pool, sizeof(*ctx), on_dispose); memset(ctx, 0, sizeof(*ctx)); ctx->generator = generator; ctx->receiver = mrb_nil_value(); h2o_buffer_init(&ctx->req.buf, &h2o_socket_buffer_prototype); h2o_buffer_init(&ctx->resp.after_closed, &h2o_socket_buffer_prototype); ctx->refs.request = mrb_nil_value(); ctx->refs.input_stream = mrb_nil_value(); /* uri */ if (h2o_url_parse(arg_url, arg_url_len, &url) != 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "invaild URL"); /* method */ method = h2o_iovec_init(H2O_STRLIT("GET")); if (mrb_hash_p(arg_hash)) { mrb_value t = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_method)); if (!mrb_nil_p(t)) { t = mrb_str_to_str(mrb, t); method = h2o_iovec_init(RSTRING_PTR(t), RSTRING_LEN(t)); } } /* start building the request */ h2o_buffer_reserve(&ctx->req.buf, method.len + 1); append_to_buffer(&ctx->req.buf, method.base, method.len); append_to_buffer(&ctx->req.buf, H2O_STRLIT(" ")); h2o_buffer_reserve(&ctx->req.buf, url.path.len + url.authority.len + sizeof(" HTTP/1.1\r\nConnection: close\r\nHost: \r\n") - 1); append_to_buffer(&ctx->req.buf, url.path.base, url.path.len); append_to_buffer(&ctx->req.buf, H2O_STRLIT(" HTTP/1.1\r\nConnection: close\r\nHost: ")); append_to_buffer(&ctx->req.buf, url.authority.base, url.authority.len); append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n")); /* headers */ if (mrb_hash_p(arg_hash)) { mrb_value headers = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_headers)); if (!mrb_nil_p(headers)) { if (h2o_mruby_iterate_headers(generator->ctx, headers, flatten_request_header, ctx) != 0) { mrb_value exc = mrb_obj_value(mrb->exc); mrb->exc = NULL; mrb_exc_raise(mrb, exc); } } } /* body */ if (mrb_hash_p(arg_hash)) { mrb_value body = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_body)); if (!mrb_nil_p(body)) { if (mrb_obj_eq(mrb, body, generator->rack_input)) { /* fast path */ mrb_int pos; mrb_input_stream_get_data(mrb, body, NULL, NULL, &pos, NULL, NULL); ctx->req.body = generator->req->entity; ctx->req.body.base += pos; ctx->req.body.len -= pos; } else { if (!mrb_string_p(body)) { body = mrb_funcall(mrb, body, "read", 0); if (!mrb_string_p(body)) mrb_raise(mrb, E_ARGUMENT_ERROR, "body.read did not return string"); } ctx->req.body = h2o_strdup(&ctx->generator->req->pool, RSTRING_PTR(body), RSTRING_LEN(body)); } if (!ctx->req.has_transfer_encoding) { char buf[64]; size_t l = (size_t)sprintf(buf, "content-length: %zu\r\n", ctx->req.body.len); h2o_buffer_reserve(&ctx->req.buf, l); append_to_buffer(&ctx->req.buf, buf, l); } } } h2o_buffer_reserve(&ctx->req.buf, 2); append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n")); /* build request and connect */ h2o_http1client_connect(&ctx->client, ctx, &generator->req->conn->ctx->proxy.client_ctx, url.host, h2o_url_get_port(&url), url.scheme == &H2O_URL_SCHEME_HTTPS, on_connect); ctx->refs.request = h2o_mruby_create_data_instance( mrb, mrb_ary_entry(generator->ctx->shared->constants, H2O_MRUBY_HTTP_REQUEST_CLASS), ctx, &request_type); return ctx->refs.request; }
static void on_gc_dispose_input_stream(mrb_state *mrb, void *_ctx) { struct st_h2o_mruby_http_request_context_t *ctx = _ctx; if (ctx != NULL) ctx->refs.input_stream = 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. */ mrb_value proc_lambda(mrb_state *mrb, mrb_value self) { //return mrb_block_lambda(); return mrb_nil_value(); /* dummy */ }
/* * call-seq: * loop { block } * loop -> an_enumerator * * Repeatedly executes the block. * * If no block is given, an enumerator is returned instead. * * loop do * print "Input: " * line = gets * break if !line or line =~ /^qQ/ * # ... * end * * StopIteration raised in the block breaks the loop. */ mrb_value mrb_f_loop(mrb_state *mrb, mrb_value self) { return mrb_nil_value(); /* dummy */ }
mrb_value mrb_hash_lookup(mrb_state *mrb, mrb_value hash, mrb_value key) { return mrb_hash_lookup2(mrb, hash, key, mrb_nil_value()); }
mrb_value send_internal(int argc, mrb_value *argv, mrb_value recv, enum call_type ctype) { return mrb_nil_value(); /* dummy */ }
// based on https://gist.github.com/3066997 static mrb_value migrate_simple_value(mrb_state *mrb, mrb_value v, mrb_state *mrb2) { mrb_value nv = mrb_nil_value(); nv.tt = v.tt; switch (mrb_type(v)) { case MRB_TT_OBJECT: nv.value.p = v.value.p; break; case MRB_TT_FALSE: case MRB_TT_TRUE: case MRB_TT_FIXNUM: nv.value.i = v.value.i; break; case MRB_TT_SYMBOL: nv = mrb_symbol_value(mrb_intern_str(mrb2, v)); break; case MRB_TT_FLOAT: nv.value.f = v.value.f; break; case MRB_TT_STRING: nv = mrb_str_new(mrb2, RSTRING_PTR(v), RSTRING_LEN(v)); break; case MRB_TT_ARRAY: { struct RArray *a0, *a1; int i; a0 = mrb_ary_ptr(v); nv = mrb_ary_new_capa(mrb2, a0->len); a1 = mrb_ary_ptr(nv); for (i=0; i<a0->len; i++) { int ai = mrb_gc_arena_save(mrb2); a1->ptr[i] = migrate_simple_value(mrb, a0->ptr[i], mrb2); a1->len++; mrb_gc_arena_restore(mrb2, ai); } } break; case MRB_TT_HASH: { mrb_value ka; int i, l; nv = mrb_hash_new(mrb2); ka = mrb_hash_keys(mrb, v); l = RARRAY_LEN(ka); for (i = 0; i < l; i++) { int ai = mrb_gc_arena_save(mrb2); mrb_value k = migrate_simple_value(mrb, mrb_ary_entry(ka, i), mrb2); mrb_value o = migrate_simple_value(mrb, mrb_hash_get(mrb, v, k), mrb2); mrb_hash_set(mrb2, nv, k, o); mrb_gc_arena_restore(mrb2, ai); } } break; default: mrb_raise(mrb, E_TYPE_ERROR, "cannot migrate object"); break; } return nv; }
static mrb_value read_value(MarshalContext *ctx) { mrb_state *mrb = ctx->mrb; char type = ctx->readByte(); mrb_value value; if (mrb->arena_idx > maxArena) maxArena = mrb->arena_idx; int arena = mrb_gc_arena_save(mrb); switch (type) { case TYPE_NIL : value = mrb_nil_value(); break; case TYPE_TRUE : value = mrb_true_value(); break; case TYPE_FALSE : value = mrb_false_value(); break; case TYPE_FIXNUM : value = mrb_fixnum_value(read_fixnum(ctx)); break; case TYPE_BIGNUM : value = mrb_fixnum_value(read_bignum(ctx)); break; case TYPE_FLOAT : value = mrb_float_value(mrb, read_float(ctx)); ctx->objects.add(value); break; case TYPE_STRING : value = read_string_value(ctx); ctx->objects.add(value); break; case TYPE_ARRAY : value = read_array(ctx); break; case TYPE_HASH : value = read_hash(ctx); break; case TYPE_SYMBOL : value = mrb_symbol_value(read_symbol(ctx)); break; case TYPE_SYMLINK : value = mrb_symbol_value(read_symlink(ctx)); break; case TYPE_OBJECT : value = read_object(ctx); break; case TYPE_IVAR : value = read_instance_var(ctx); break; case TYPE_LINK : value = read_link(ctx); break; case TYPE_USERDEF : value = read_userdef(ctx); ctx->objects.add(value); break; default : CCLOG( "Marshal.load: unsupported value type '%c',gbufsize %d",type,g_buf_size); CCAssert(false,"f**k"); //exit(0); } mrb_gc_arena_restore(mrb, arena); return value; }
static int read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32_t* len) { int i, ret = MRB_DUMP_OK; char *buf; unsigned char *recordStart, *pStart; uint16_t crc, tt, pdl, snl, offset, bufsize=MRB_DUMP_DEFAULT_STR_LEN; mrb_int fix_num; mrb_float f; mrb_value str; recordStart = src; buf = mrb_malloc(mrb, bufsize); if (buf == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } //Header Section pStart = src; if (*src != RITE_IREP_IDENFIFIER) return MRB_DUMP_INVALID_IREP; src += (sizeof(unsigned char) * 2); irep->nlocals = bin_to_uint16(src); //number of local variable src += MRB_DUMP_SIZE_OF_SHORT; irep->nregs = bin_to_uint16(src); //number of register variable src += MRB_DUMP_SIZE_OF_SHORT; offset = bin_to_uint16(src); //offset of isec block src += MRB_DUMP_SIZE_OF_SHORT; crc = calc_crc_16_ccitt(pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) //header CRC return MRB_DUMP_INVALID_IREP; src += offset; //Binary Data Section //ISEQ BLOCK pStart = src; irep->ilen = bin_to_uint32(src); //iseq length src += MRB_DUMP_SIZE_OF_LONG; if (irep->ilen > 0) { if ((irep->iseq = mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i=0; i<irep->ilen; i++) { irep->iseq[i] = bin_to_uint32(src); //iseq src += MRB_DUMP_SIZE_OF_LONG; } } crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //iseq CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; //POOL BLOCK pStart = src; irep->plen = bin_to_uint32(src); //pool length src += MRB_DUMP_SIZE_OF_LONG; if (irep->plen > 0) { irep->pool = mrb_malloc(mrb, sizeof(mrb_value) * irep->plen); if (irep->pool == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } for (i=0; i<irep->plen; i++) { tt = *src; //pool TT src += sizeof(unsigned char); pdl = bin_to_uint16(src); //pool data length src += MRB_DUMP_SIZE_OF_SHORT; if (pdl > bufsize - 1) { mrb_free(mrb, buf); bufsize = pdl + 1; if ((buf = mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } } memcpy(buf, src, pdl); src += pdl; buf[pdl] = '\0'; switch (tt) { //pool data case MRB_TT_FIXNUM: fix_num = readint(buf, 10); irep->pool[i] = mrb_fixnum_value(fix_num); break; case MRB_TT_FLOAT: f = readfloat(buf); irep->pool[i] = mrb_float_value(f); break; case MRB_TT_STRING: irep->pool[i] = mrb_str_new(mrb, buf, pdl); break; #ifdef INCLUDE_REGEXP case MRB_TT_REGEX: str = mrb_str_new(mrb, buf, pdl); irep->pool[i] = mrb_reg_quote(mrb, str); break; #endif default: irep->pool[i] = mrb_nil_value(); break; } } } crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //pool CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; //SYMS BLOCK pStart = src; irep->slen = bin_to_uint32(src); //syms length src += MRB_DUMP_SIZE_OF_LONG; if (irep->slen > 0) { if ((irep->syms = mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } memset(irep->syms, 0, sizeof(mrb_sym)*(irep->slen)); for (i=0; i<irep->slen; i++) { snl = bin_to_uint16(src); //symbol name length src += MRB_DUMP_SIZE_OF_SHORT; if (snl == MRB_DUMP_NULL_SYM_LEN) { irep->syms[i] = 0; continue; } if (snl > bufsize - 1) { mrb_free(mrb, buf); bufsize = snl + 1; if ((buf = mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } } memcpy(buf, src, snl); //symbol name src += snl; buf[snl] = '\0'; irep->syms[i] = mrb_intern(mrb, buf); } } crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //syms CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; *len = src - recordStart; error_exit: if (buf) mrb_free(mrb, buf); return ret; }
/* set_fade_level * * Parameters: * - value: Uint16 */ mrb_value mrb_SDL_SDLHapticConstant_set_fade_level(mrb_state* mrb, mrb_value self) { struct SDL_HapticConstant * native_self = mruby_unbox_SDL_HapticConstant(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint16 native_field = mrb_fixnum(ruby_field); native_self->fade_level = native_field; return ruby_field; }
// like Nginx rewrite keywords // used like this: // => http code 3xx location in browser // => internal redirection in nginx static mrb_value ngx_mrb_redirect(mrb_state *mrb, mrb_value self) { int argc; u_char *str; ngx_buf_t *b; ngx_int_t rc; mrb_value uri, code; ngx_str_t ns; ngx_http_mruby_ctx_t *ctx; ngx_table_elt_t *location; ngx_mrb_rputs_chain_list_t *chain; ngx_http_request_t *r = ngx_mrb_get_request(); argc = mrb_get_args(mrb, "o|oo", &uri, &code); // get status code from args if (argc == 2) { rc = mrb_fixnum(code); } else { rc = NGX_HTTP_MOVED_TEMPORARILY; } // get redirect uri from args if (mrb_type(uri) != MRB_TT_STRING) { uri = mrb_funcall(mrb, uri, "to_s", 0, NULL); } // save location uri to ns ns.data = (u_char *)RSTRING_PTR(uri); ns.len = ngx_strlen(ns.data); if (ns.len == 0) { return mrb_nil_value(); } // if uri start with scheme prefix // return 3xx for redirect // else generate a internal redirection and response to raw request // request.path is not changed if (ngx_strncmp(ns.data, "http://", sizeof("http://") - 1) == 0 || ngx_strncmp(ns.data, "https://", sizeof("https://") - 1) == 0 || ngx_strncmp(ns.data, "$scheme", sizeof("$scheme") - 1) == 0) { ctx = ngx_http_get_module_ctx(r, ngx_http_mruby_module); if (ctx == NULL) { ngx_log_error(NGX_LOG_ERR , r->connection->log , 0 , "get mruby context failed." ); } if (ctx->rputs_chain == NULL) { chain = ngx_pcalloc(r->pool, sizeof(ngx_mrb_rputs_chain_list_t)); chain->out = ngx_alloc_chain_link(r->pool); chain->last = &chain->out; } else { chain = ctx->rputs_chain; (*chain->last)->next = ngx_alloc_chain_link(r->pool); chain->last = &(*chain->last)->next; } // allocate space for body b = ngx_calloc_buf(r->pool); (*chain->last)->buf = b; (*chain->last)->next = NULL; str = ngx_pstrdup(r->pool, &ns); str[ns.len] = '\0'; (*chain->last)->buf->pos = str; (*chain->last)->buf->last = str+ns.len; (*chain->last)->buf->memory = 1; ctx->rputs_chain = chain; ngx_http_set_ctx(r, ctx, ngx_http_mruby_module); if (r->headers_out.content_length_n == -1) { r->headers_out.content_length_n += ns.len + 1; } else { r->headers_out.content_length_n += ns.len; } // build redirect location location = ngx_list_push(&r->headers_out.headers); location->hash = 1; ngx_str_set(&location->key, "Location"); location->value = ns; location->lowcase_key = ngx_pnalloc(r->pool, location->value.len); ngx_strlow(location->lowcase_key, location->value.data, location->value.len); // set location and response code for hreaders r->headers_out.location = location; r->headers_out.status = rc; ngx_http_send_header(r); ngx_http_output_filter(r, chain->out); } else { ngx_http_internal_redirect(r, &ns, &r->args); } return self; }
//************************************************** // 隠しコマンドです: El_Psy.Congroo // El_Psy.Congroo() //************************************************** mrb_value mrb_El_Psy_congroo(mrb_state *mrb, mrb_value self) { mrb_raise(mrb, mrb_class_get(mrb, "Sys#exit Called"), "Normal Completion"); return mrb_nil_value(); //戻り値は無しですよ。 }
//************************************************** // アナログDACピン初期化: initDac // initDac() //************************************************** mrb_value mrb_kernel_initDac(mrb_state *mrb, mrb_value self) { setPinModeDac(RB_PIN9); return mrb_nil_value(); //戻り値は無しですよ。 }
mrb_value test_init(mrb_state* mrb, mrb_value exec) { printf("Test.initialize is called\n"); return mrb_nil_value(); }
mrb_value mrb_block_proc(void) { return mrb_nil_value();//proc_new(mrb_cProc, FALSE); }
/* set_type * * Parameters: * - value: Uint32 */ mrb_value mrb_SDL_SDLDollarGestureEvent_set_type(mrb_state* mrb, mrb_value self) { struct SDL_DollarGestureEvent * native_self = mruby_unbox_SDL_DollarGestureEvent(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint32 native_field = mrb_fixnum(ruby_field); native_self->type = native_field; return ruby_field; }
void mruby_Git_define_macro_constants(mrb_state* mrb) { /* MRUBY_BINDING: pre_macro_definitions */ /* sha: user_defined */ /* MRUBY_BINDING_END */ #ifdef GIT_DEFAULT_PORT do { mrb_value macro = GIT_DEFAULT_PORT == NULL ? mrb_nil_value() : mrb_str_new_cstr(mrb, GIT_DEFAULT_PORT); mrb_define_const(mrb, Git_module(mrb), "GIT_DEFAULT_PORT", macro); } while (0); #endif #ifdef GIT_DESCRIBE_DEFAULT_ABBREVIATED_SIZE do { mrb_value macro = mrb_fixnum_value(GIT_DESCRIBE_DEFAULT_ABBREVIATED_SIZE); mrb_define_const(mrb, Git_module(mrb), "GIT_DESCRIBE_DEFAULT_ABBREVIATED_SIZE", macro); } while (0); #endif #ifdef GIT_DESCRIBE_DEFAULT_MAX_CANDIDATES_TAGS do { mrb_value macro = mrb_fixnum_value(GIT_DESCRIBE_DEFAULT_MAX_CANDIDATES_TAGS); mrb_define_const(mrb, Git_module(mrb), "GIT_DESCRIBE_DEFAULT_MAX_CANDIDATES_TAGS", macro); } while (0); #endif #ifdef GIT_IDXENTRY_NAMEMASK do { mrb_value macro = mrb_fixnum_value(GIT_IDXENTRY_NAMEMASK); mrb_define_const(mrb, Git_module(mrb), "GIT_IDXENTRY_NAMEMASK", macro); } while (0); #endif #ifdef GIT_IDXENTRY_STAGEMASK do { mrb_value macro = mrb_fixnum_value(GIT_IDXENTRY_STAGEMASK); mrb_define_const(mrb, Git_module(mrb), "GIT_IDXENTRY_STAGEMASK", macro); } while (0); #endif #ifdef GIT_IDXENTRY_STAGESHIFT do { mrb_value macro = mrb_fixnum_value(GIT_IDXENTRY_STAGESHIFT); mrb_define_const(mrb, Git_module(mrb), "GIT_IDXENTRY_STAGESHIFT", macro); } while (0); #endif #ifdef GIT_OID_HEX_ZERO do { mrb_value macro = GIT_OID_HEX_ZERO == NULL ? mrb_nil_value() : mrb_str_new_cstr(mrb, GIT_OID_HEX_ZERO); mrb_define_const(mrb, Git_module(mrb), "GIT_OID_HEX_ZERO", macro); } while (0); #endif #ifdef GIT_OID_HEXSZ do { mrb_value macro = mrb_fixnum_value(GIT_OID_HEXSZ); mrb_define_const(mrb, Git_module(mrb), "GIT_OID_HEXSZ", macro); } while (0); #endif #ifdef GIT_OID_MINPREFIXLEN do { mrb_value macro = mrb_fixnum_value(GIT_OID_MINPREFIXLEN); mrb_define_const(mrb, Git_module(mrb), "GIT_OID_MINPREFIXLEN", macro); } while (0); #endif #ifdef GIT_OID_RAWSZ do { mrb_value macro = mrb_fixnum_value(GIT_OID_RAWSZ); mrb_define_const(mrb, Git_module(mrb), "GIT_OID_RAWSZ", macro); } while (0); #endif #ifdef GIT_PATH_LIST_SEPARATOR do { mrb_value macro = mrb_fixnum_value(GIT_PATH_LIST_SEPARATOR); mrb_define_const(mrb, Git_module(mrb), "GIT_PATH_LIST_SEPARATOR", macro); } while (0); #endif #ifdef GIT_PATH_MAX do { mrb_value macro = mrb_fixnum_value(GIT_PATH_MAX); mrb_define_const(mrb, Git_module(mrb), "GIT_PATH_MAX", macro); } while (0); #endif #ifdef GIT_REBASE_NO_OPERATION do { mrb_value macro = mrb_fixnum_value(GIT_REBASE_NO_OPERATION); mrb_define_const(mrb, Git_module(mrb), "GIT_REBASE_NO_OPERATION", macro); } while (0); #endif #ifdef GIT_STATUS_OPT_DEFAULTS do { mrb_value macro = mrb_fixnum_value(GIT_STATUS_OPT_DEFAULTS); mrb_define_const(mrb, Git_module(mrb), "GIT_STATUS_OPT_DEFAULTS", macro); } while (0); #endif #ifdef LIBGIT2_VER_MAJOR do { mrb_value macro = mrb_fixnum_value(LIBGIT2_VER_MAJOR); mrb_define_const(mrb, Git_module(mrb), "LIBGIT2_VER_MAJOR", macro); } while (0); #endif #ifdef LIBGIT2_VER_MINOR do { mrb_value macro = mrb_fixnum_value(LIBGIT2_VER_MINOR); mrb_define_const(mrb, Git_module(mrb), "LIBGIT2_VER_MINOR", macro); } while (0); #endif #ifdef LIBGIT2_VER_PATCH do { mrb_value macro = mrb_fixnum_value(LIBGIT2_VER_PATCH); mrb_define_const(mrb, Git_module(mrb), "LIBGIT2_VER_PATCH", macro); } while (0); #endif #ifdef LIBGIT2_VER_REVISION do { mrb_value macro = mrb_fixnum_value(LIBGIT2_VER_REVISION); mrb_define_const(mrb, Git_module(mrb), "LIBGIT2_VER_REVISION", macro); } while (0); #endif #ifdef LIBGIT2_VERSION do { mrb_value macro = LIBGIT2_VERSION == NULL ? mrb_nil_value() : mrb_str_new_cstr(mrb, LIBGIT2_VERSION); mrb_define_const(mrb, Git_module(mrb), "LIBGIT2_VERSION", macro); } while (0); #endif /* MRUBY_BINDING: post_macro_definitions */ /* sha: user_defined */ /* MRUBY_BINDING_END */ }