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 */
}
