static mrb_value
inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
{
mrb_value str, str2;
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (recur) return mrb_str_new_lit(mrb, "{...}");
str = mrb_str_new_lit(mrb, "{");
if (h && kh_size(h) > 0) {
for (k = kh_begin(h); k != kh_end(h); k++) {
int ai;
if (!kh_exist(h,k)) continue;
ai = mrb_gc_arena_save(mrb);
if (RSTRING_LEN(str) > 1) mrb_str_cat_lit(mrb, str, ", ");
str2 = mrb_inspect(mrb, kh_key(h,k));
mrb_str_append(mrb, str, str2);
mrb_str_cat_lit(mrb, str, "=>");
str2 = mrb_inspect(mrb, kh_value(h,k));
mrb_str_append(mrb, str, str2);
mrb_gc_arena_restore(mrb, ai);
}
}
mrb_str_cat_lit(mrb, str, "}");
return str;
}
static mrb_value
method_to_s(mrb_state *mrb, mrb_value self)
{
mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"));
mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass"));
mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
mrb_value str = mrb_str_new_lit(mrb, "#<");
struct RClass *rklass;
mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, self));
mrb_str_cat_lit(mrb, str, ": ");
rklass = mrb_class_ptr(klass);
if (mrb_class_ptr(owner) == rklass) {
mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
mrb_str_cat_lit(mrb, str, "#");
mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
}
else {
mrb_str_cat_cstr(mrb, str, mrb_class_name(mrb, rklass));
mrb_str_cat_lit(mrb, str, "(");
mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
mrb_str_cat_lit(mrb, str, ")#");
mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
static mrb_value
mrb_proc_inspect(mrb_state *mrb, mrb_value self)
{
struct RProc *p = mrb_proc_ptr(self);
mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
if (!MRB_PROC_CFUNC_P(p)) {
mrb_irep *irep = p->body.irep;
const char *filename;
int32_t line;
mrb_str_cat_lit(mrb, str, "@");
filename = mrb_debug_get_filename(irep, 0);
mrb_str_cat_cstr(mrb, str, filename ? filename : "-");
mrb_str_cat_lit(mrb, str, ":");
line = mrb_debug_get_line(irep, 0);
if (line != -1) {
mrb_str_append(mrb, str, mrb_fixnum_value(line));
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
}
if (MRB_PROC_STRICT_P(p)) {
mrb_str_cat_lit(mrb, str, " (lambda)");
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
void
test_gc_gray_mark(void)
{
mrb_state *mrb = mrb_open();
mrb_value obj_v, value_v;
struct RBasic *obj;
size_t gray_num = 0;
puts("test_gc_gray_mark");
puts(" in MRB_TT_CLASS");
obj = (struct RBasic*)mrb->object_class;
paint_gray(obj);
gray_num = gc_gray_mark(mrb, obj);
mrb_assert(is_black(obj));
mrb_assert(gray_num > 1);
puts(" in MRB_TT_ARRAY");
obj_v = mrb_ary_new(mrb);
value_v = mrb_str_new_lit(mrb, "test");
paint_gray(mrb_basic_ptr(obj_v));
paint_partial_white(mrb, mrb_basic_ptr(value_v));
mrb_ary_push(mrb, obj_v, value_v);
gray_num = gc_gray_mark(mrb, mrb_basic_ptr(obj_v));
mrb_assert(is_black(mrb_basic_ptr(obj_v)));
mrb_assert(is_gray(mrb_basic_ptr(value_v)));
mrb_assert(gray_num == 1);
mrb_close(mrb);
}
static unsigned int mrb_http2_config_get_worker(mrb_state *mrb, mrb_value args, mrb_value w)
{
int worker;
// worker => fixnum or "auto"
if (!mrb_nil_p(w)) {
if (mrb_type(w) == MRB_TT_STRING
&& mrb_equal(mrb, w, mrb_str_new_lit(mrb, "auto"))) {
worker = sysconf(_SC_NPROCESSORS_ONLN);
if (worker < 0 || worker > MRB_HTTP2_WORKER_MAX) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed sysconf(_SC_NPROCESSORS_ONLN)");
}
} else if (mrb_type(w) == MRB_TT_FIXNUM) {
worker = mrb_fixnum(w);
} else {
mrb_raisef(mrb, E_RUNTIME_ERROR, "invalid worker parmeter: %S", w);
}
if (worker > MRB_HTTP2_WORKER_MAX) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "invalid worker parameter: "
"%S > MRB_HTTP2_WORKER_MAX(%S)", mrb_fixnum_value(worker),
mrb_fixnum_value(MRB_HTTP2_WORKER_MAX));
}
} else {
worker = 0;
}
#if !defined(__linux__) || !defined(SO_REUSEPORT)
worker = 0;
#endif
return worker;
}
static mrb_value
mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
{
char buf[66], *b = buf + sizeof buf;
mrb_int num = mrb_fixnum(x);
uint64_t val = (uint64_t)num;
char d;
if (base != 2) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base));
}
if (val == 0) {
return mrb_str_new_lit(mrb, "0");
}
*--b = '\0';
do {
*--b = mrb_digitmap[(int)(val % base)];
} while (val /= base);
if (num < 0) {
b = remove_sign_bits(b, base);
switch (base) {
case 16: d = 'f'; break;
case 8: d = '7'; break;
case 2: d = '1'; break;
default: d = 0; break;
}
if (d && *b != d) {
*--b = d;
}
}
return mrb_str_new_cstr(mrb, b);
}
static mrb_value
mrb_proc_inspect(mrb_state *mrb, mrb_value self)
{
struct RProc *p = mrb_proc_ptr(self);
mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
if (!MRB_PROC_CFUNC_P(p)) {
mrb_irep *irep = p->body.irep;
mrb_str_cat_lit(mrb, str, "@");
if (irep->filename) {
mrb_str_cat_cstr(mrb, str, irep->filename);
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
mrb_str_cat_lit(mrb, str, ":");
if (irep->lines) {
mrb_str_append(mrb, str, mrb_fixnum_value(*irep->lines));
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
}
if (MRB_PROC_STRICT_P(p)) {
mrb_str_cat_lit(mrb, str, " (lambda)");
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
static mrb_value
flo_to_s(mrb_state *mrb, mrb_value flt)
{
if (isnan(mrb_float(flt))) {
return mrb_str_new_lit(mrb, "NaN");
}
return mrb_float_to_str(mrb, flt, MRB_FLO_TO_STR_FMT);
}
void
mrb_show_version(mrb_state *mrb)
{
mrb_value msg;
msg = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_DESCRIPTION"));
printstr(mrb, msg);
printstr(mrb, mrb_str_new_lit(mrb, "\n"));
}
static mrb_value
mrb_hash_inspect(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
if (!h || kh_size(h) == 0)
return mrb_str_new_lit(mrb, "{}");
return inspect_hash(mrb, hash, 0);
}
void
mrb_show_copyright(mrb_state *mrb)
{
mrb_value msg;
msg = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_COPYRIGHT"));
printstr(mrb, msg);
printstr(mrb, mrb_str_new_lit(mrb, "\n"));
}
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);
mrb_assert(mrb->gray_list == NULL);
obj1 = mrb_basic_ptr(mrb_str_new_lit(mrb, "test"));
add_gray_list(mrb, obj1);
mrb_assert(mrb->gray_list == obj1);
mrb_assert(is_gray(obj1));
obj2 = mrb_basic_ptr(mrb_str_new_lit(mrb, "test"));
add_gray_list(mrb, obj2);
mrb_assert(mrb->gray_list == obj2);
mrb_assert(mrb->gray_list->gcnext == obj1);
mrb_assert(is_gray(obj2));
mrb_close(mrb);
}
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;
}
int main(void)
{
mrb_value response;
mrb_state *mrb = mrb_open();
mrbc_context *ctx = mrbc_context_new(mrb);
// URL into instance variable "@url" of main on same ctx
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@url"),
mrb_str_new_lit(mrb, "https://127.0.0.1:8080/index.html"));
response = mrb_load_string_cxt(mrb, request, ctx);
mrb_funcall(mrb, mrb_top_self(mrb), "pp", 1, response);
mrbc_context_free(mrb, ctx);
mrb_close(mrb);
return 0;
}
void
mrb_init_version(mrb_state* mrb)
{
mrb_value mruby_version = mrb_str_new_lit(mrb, MRUBY_VERSION);
mrb_define_global_const(mrb, "RUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_RUBY_VERSION));
mrb_define_global_const(mrb, "RUBY_ENGINE", mrb_str_new_lit(mrb, MRUBY_RUBY_ENGINE));
mrb_define_global_const(mrb, "RUBY_ENGINE_VERSION", mruby_version);
mrb_define_global_const(mrb, "MRUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_VERSION));
mrb_define_global_const(mrb, "MRUBY_RELEASE_NO", mrb_fixnum_value(MRUBY_RELEASE_NO));
mrb_define_global_const(mrb, "MRUBY_RELEASE_DATE", mrb_str_new_lit(mrb, MRUBY_RELEASE_DATE));
mrb_define_global_const(mrb, "MRUBY_DESCRIPTION", mrb_str_new_lit(mrb, MRUBY_DESCRIPTION));
mrb_define_global_const(mrb, "MRUBY_COPYRIGHT", mrb_str_new_lit(mrb, MRUBY_COPYRIGHT));
}
s.run \n\
";
int main(void)
{
mrb_state *mrb = mrb_open();
mrbc_context *ctx = mrbc_context_new(mrb);
// 8080 into instance variable "@port" of main on same ctx
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@port"),
mrb_fixnum_value(8080));
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@echo_content"),
mrb_str_new_lit(mrb, "world from cb."));
mrb_load_string_cxt(mrb, config, ctx);
mrb_load_string_cxt(mrb, response, ctx);
mrb_load_string_cxt(mrb, run, ctx);
mrbc_context_free(mrb, ctx);
mrb_close(mrb);
return 0;
}
static mrb_value ngx_mrb_get_nginx_version(mrb_state *mrb, mrb_value self)
{
return mrb_str_new_lit(mrb, NGINX_VERSION);
}
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);
}
static mrb_value ngx_http_mruby_get_nginx_configure(mrb_state *mrb, mrb_value self)
{
return mrb_str_new_lit(mrb, NGX_CONFIGURE);
}
/*
* call-seq:
* string.succ -> string
*
* Returns next sequence of the string;
*
* a = "abc"
* a.succ #=> "abd"
*/
static mrb_value
mrb_str_succ_bang(mrb_state *mrb, mrb_value self)
{
mrb_value result;
unsigned char *p, *e, *b, *t;
const char *prepend;
struct RString *s = mrb_str_ptr(self);
size_t l;
if (RSTRING_LEN(self) == 0)
return self;
mrb_str_modify(mrb, s);
l = RSTRING_LEN(self);
b = p = (unsigned char*) RSTRING_PTR(self);
t = e = p + l;
*(e--) = 0;
// find trailing ascii/number
while (e >= b) {
if (ISALNUM(*e))
break;
e--;
}
if (e < b) {
e = p + l - 1;
result = mrb_str_new_lit(mrb, "");
} else {
// find leading letter of the ascii/number
b = e;
while (b > p) {
if (!ISALNUM(*b) || (ISALNUM(*b) && *b != '9' && *b != 'z' && *b != 'Z'))
break;
b--;
}
if (!ISALNUM(*b))
b++;
result = mrb_str_new(mrb, (char*) p, b - p);
}
while (e >= b) {
if (!ISALNUM(*e)) {
if (*e == 0xff) {
mrb_str_cat_lit(mrb, result, "\x01");
(*e) = 0;
} else
(*e)++;
break;
}
prepend = NULL;
if (*e == '9') {
if (e == b) prepend = "1";
*e = '0';
} else if (*e == 'z') {
if (e == b) prepend = "a";
*e = 'a';
} else if (*e == 'Z') {
if (e == b) prepend = "A";
*e = 'A';
} else {
(*e)++;
break;
}
if (prepend) mrb_str_cat_cstr(mrb, result, prepend);
e--;
}
result = mrb_str_cat(mrb, result, (char*) b, t - b);
l = RSTRING_LEN(result);
mrb_str_resize(mrb, self, l);
memcpy(RSTRING_PTR(self), RSTRING_PTR(result), l);
return self;
}
static mrb_value
inspect_main(mrb_state *mrb, mrb_value mod)
{
return mrb_str_new_lit(mrb, "main");
}
static mrb_value ngx_mrb_echo(mrb_state *mrb, mrb_value self)
{
mrb_value argv;
ngx_buf_t *b;
ngx_mrb_rputs_chain_list_t *chain;
u_char *str;
ngx_str_t ns;
ngx_http_request_t *r = ngx_mrb_get_request();
ngx_http_mruby_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_mruby_module);
mrb_get_args(mrb, "o", &argv);
if (mrb_type(argv) != MRB_TT_STRING) {
argv = mrb_funcall(mrb, argv, "to_s", 0, NULL);
}
ns.data = (u_char *)RSTRING_PTR(mrb_str_plus(mrb, argv, mrb_str_new_lit(mrb, "\n")));
ns.len = RSTRING_LEN(argv) + sizeof("\n") - 1;
if (ns.len == 0) {
return self;
}
if (ctx->rputs_chain == NULL) {
chain = ngx_pcalloc(r->pool, sizeof(ngx_mrb_rputs_chain_list_t));
if (chain == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed to allocate memory");
}
chain->out = ngx_alloc_chain_link(r->pool);
if (chain->out == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed to allocate memory");
}
chain->last = &chain->out;
} else {
chain = ctx->rputs_chain;
(*chain->last)->next = ngx_alloc_chain_link(r->pool);
if ((*chain->last)->next == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed to allocate memory");
}
chain->last = &(*chain->last)->next;
}
b = ngx_calloc_buf(r->pool);
if (b == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed to allocate memory");
}
(*chain->last)->buf = b;
(*chain->last)->next = NULL;
str = ngx_pstrdup(r->pool, &ns);
if (str == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "failed to allocate memory");
}
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;
}
return self;
}
int value_to_node(mrb_state *mrb,
yaml_document_t *document, mrb_value value)
{
int node;
switch (mrb_type(value))
{
case MRB_TT_ARRAY:
{
mrb_int len = mrb_ary_len(mrb, value);
mrb_int i;
int ai = mrb_gc_arena_save(mrb);
node = yaml_document_add_sequence(document, NULL,
YAML_ANY_SEQUENCE_STYLE);
for (i = 0; i < len; i++)
{
mrb_value child = mrb_ary_ref(mrb, value, i);
int child_node = value_to_node(mrb, document, child);
/* Add the child to the sequence */
yaml_document_append_sequence_item(document, node, child_node);
mrb_gc_arena_restore(mrb, ai);
}
break;
}
case MRB_TT_HASH:
{
/* Iterating a list of keys is slow, but it only
* requires use of the interface defined in `hash.h`.
*/
mrb_value keys = mrb_hash_keys(mrb, value);
mrb_int len = mrb_ary_len(mrb, keys);
mrb_int i;
int ai = mrb_gc_arena_save(mrb);
node = yaml_document_add_mapping(document, NULL,
YAML_ANY_MAPPING_STYLE);
for (i = 0; i < len; i++)
{
mrb_value key = mrb_ary_ref(mrb, keys, i);
mrb_value child = mrb_hash_get(mrb, value, key);
int key_node = value_to_node(mrb, document, key);
int child_node = value_to_node(mrb, document, child);
/* Add the key/value pair to the mapping */
yaml_document_append_mapping_pair(document, node,
key_node, child_node);
mrb_gc_arena_restore(mrb, ai);
}
break;
}
default:
{
if (mrb_nil_p(value)) {
/* http://yaml.org/type/null.html
Canonical form */
value = mrb_str_new_lit(mrb, "~");
} else {
/* Equivalent to `obj = obj#to_s` */
value = mrb_obj_as_string(mrb, value);
}
/* Fallthrough */
}
case MRB_TT_STRING:
{
yaml_scalar_style_t style = YAML_ANY_SCALAR_STYLE;
if (RSTRING_LEN(value) == 0) {
/* If the String is empty, it may be reloaded as a nil instead of an
* empty string, to avoid that place a quoted string instead */
style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
}
yaml_char_t *value_chars = (unsigned char *) RSTRING_PTR(value);
node = yaml_document_add_scalar(document, NULL,
value_chars, RSTRING_LEN(value), style);
break;
}
}
return node;
}
static mrb_value
false_to_s(mrb_state *mrb, mrb_value obj)
{
return mrb_str_new_lit(mrb, "false");
}
static mrb_value
nil_inspect(mrb_state *mrb, mrb_value obj)
{
return mrb_str_new_lit(mrb, "nil");
}
static mrb_value
true_to_s(mrb_state *mrb, mrb_value obj)
{
return mrb_str_new_lit(mrb, "true");
}
static mrb_value ngx_mrb_server_name(mrb_state *mrb, mrb_value self)
{
return mrb_str_new_lit(mrb, NGINX_VAR);
}
static mrb_value
mrb_flo_to_str(mrb_state *mrb, mrb_float flo)
{
double n = (double)flo;
int max_digits = FLO_MAX_DIGITS;
if (isnan(n)) {
return mrb_str_new_lit(mrb, "NaN");
}
else if (isinf(n)) {
if (n < 0) {
return mrb_str_new_lit(mrb, "-inf");
}
else {
return mrb_str_new_lit(mrb, "inf");
}
}
else {
int digit;
int m = 0;
int exp;
mrb_bool e = FALSE;
char s[48];
char *c = &s[0];
int length = 0;
if (signbit(n)) {
n = -n;
*(c++) = '-';
}
if (n != 0.0) {
if (n > 1.0) {
exp = (int)floor(log10(n));
}
else {
exp = (int)-ceil(-log10(n));
}
}
else {
exp = 0;
}
/* preserve significands */
if (exp < 0) {
int i, beg = -1, end = 0;
double f = n;
double fd = 0;
for (i = 0; i < FLO_MAX_DIGITS; ++i) {
f = (f - fd) * 10.0;
fd = floor(f + FLO_EPSILON);
if (fd != 0) {
if (beg < 0) beg = i;
end = i + 1;
}
}
if (beg >= 0) length = end - beg;
if (length > FLO_MAX_SIGN_LENGTH) length = FLO_MAX_SIGN_LENGTH;
}
if (abs(exp) + length >= FLO_MAX_DIGITS) {
/* exponent representation */
e = TRUE;
n = n / pow(10.0, exp);
if (isinf(n)) {
if (s < c) { /* s[0] == '-' */
return mrb_str_new_lit(mrb, "-0.0");
}
else {
return mrb_str_new_lit(mrb, "0.0");
}
}
}
else {
/* un-exponent (normal) representation */
if (exp > 0) {
m = exp;
}
}
/* puts digits */
while (max_digits >= 0) {
double weight = (m < 0) ? 0.0 : pow(10.0, m);
double fdigit = (m < 0) ? n * 10.0 : n / weight;
if (fdigit < 0) fdigit = n = 0;
if (m < -1 && fdigit < FLO_EPSILON) {
if (e || exp > 0 || m <= -abs(exp)) {
break;
}
}
digit = (int)floor(fdigit + FLO_EPSILON);
if (m == 0 && digit > 9) {
n /= 10.0;
exp++;
continue;
}
*(c++) = '0' + digit;
n = (m < 0) ? n * 10.0 - digit : n - (digit * weight);
max_digits--;
if (m-- == 0) {
*(c++) = '.';
}
}
if (c[-1] == '0') {
while (&s[0] < c && c[-1] == '0') {
c--;
}
c++;
}
if (e) {
*(c++) = 'e';
if (exp > 0) {
*(c++) = '+';
}
else {
*(c++) = '-';
exp = -exp;
}
if (exp >= 100) {
*(c++) = '0' + exp / 100;
exp -= exp / 100 * 100;
}
*(c++) = '0' + exp / 10;
*(c++) = '0' + exp % 10;
}
*c = '\0';
return mrb_str_new(mrb, &s[0], c - &s[0]);
}
}
static mrb_value ngx_mrb_get_ngx_mruby_version(mrb_state *mrb, mrb_value self)
{
return mrb_str_new_lit(mrb, MODULE_VERSION);
}
static mrb_value ngx_mrb_get_ngx_mruby_name(mrb_state *mrb, mrb_value self)
{
return mrb_str_new_lit(mrb, MODULE_NAME);
}