static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr;
mrb_sym id;
struct RClass *c;
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_obj_to_sym(mrb, name);
if (!is_const_id(mrb, mrb_sym2name_len(mrb, id, NULL))) {
mrb_name_error(mrb, id, "identifier %S needs to be constant", name);
}
if (mrb_const_defined_at(mrb, mrb_obj_value(klass), id)) {
mrb_warn(mrb, "redefining constant Struct::%S", name);
/* ?rb_mod_remove_const(klass, mrb_sym2name(mrb, id)); */
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE());
/* RSTRUCT(nstr)->basic.c->super = c->c; */
make_struct_define_accessors(mrb, members, c);
return nstr;
}
/*
* call-seq:
* str.prepend(other_str) -> str
*
* Prepend---Prepend the given string to <i>str</i>.
*
* a = "world"
* a.prepend("hello ") #=> "hello world"
* a #=> "hello world"
*/
static mrb_value
mrb_str_prepend(mrb_state *mrb, mrb_value self)
{
struct RString *s1 = mrb_str_ptr(self), *s2, *temp_s;
mrb_int len;
mrb_value other, temp_str;
mrb_get_args(mrb, "S", &other);
mrb_str_modify(mrb, s1);
if (!mrb_string_p(other)) {
other = mrb_str_to_str(mrb, other);
}
s2 = mrb_str_ptr(other);
len = RSTR_LEN(s1) + RSTR_LEN(s2);
temp_str = mrb_str_new(mrb, NULL, RSTR_LEN(s1));
temp_s = mrb_str_ptr(temp_str);
memcpy(RSTR_PTR(temp_s), RSTR_PTR(s1), RSTR_LEN(s1));
if (RSTRING_CAPA(self) < len) {
mrb_str_resize(mrb, self, len);
}
memcpy(RSTR_PTR(s1), RSTR_PTR(s2), RSTR_LEN(s2));
memcpy(RSTR_PTR(s1) + RSTR_LEN(s2), RSTR_PTR(temp_s), RSTR_LEN(temp_s));
RSTR_SET_LEN(s1, len);
RSTR_PTR(s1)[len] = '\0';
return self;
}
static ssize_t
mrb_wslay_event_recv_callback(wslay_event_context_ptr ctx,
uint8_t *buf, size_t len, int flags, void *user_data)
{
mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
mrb_state*mrb = data->mrb;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
struct mrb_jmpbuf c_jmp;
mrb_int ret = -1;
MRB_TRY(&c_jmp) {
mrb->jmp = &c_jmp;
mrb_value argv[2];
argv[0] = mrb_cptr_value(mrb, buf);
argv[1] = mrb_fixnum_value(len);
errno = 0;
mrb_assert(mrb_type(data->recv_callback) == MRB_TT_PROC);
mrb_value buf_obj = mrb_yield_argv(mrb, data->recv_callback, NELEMS(argv), argv);
if (mrb_fixnum_p(buf_obj)) {
ret = mrb_fixnum(buf_obj);
} else {
buf_obj = mrb_str_to_str(mrb, buf_obj);
ret = RSTRING_LEN(buf_obj);
if (ret < 0||ret > len) {
mrb_raise(mrb, E_RANGE_ERROR, "returned buf doesn't fit");
}
if (ret > 0) {
memmove(buf, (uint8_t *) RSTRING_PTR(buf_obj), ret);
}
}
mrb->jmp = prev_jmp;
} MRB_CATCH(&c_jmp) {
mrb->jmp = prev_jmp;
if (mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EAGAIN"))||
mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EWOULDBLOCK"))) {
mrb->exc = NULL;
wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
} else {
wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
}
} MRB_END_EXC(&c_jmp);
mrb_gc_arena_restore(mrb, ai);
return ret;
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr, *ptr_members;
mrb_sym id;
long i, len;
struct RClass *c;
//OBJ_FREEZE(members);
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
//mrb_make_metaclass(nstr, RBASIC(klass)->c);
//mrb_class_inherited(klass, nstr);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_to_id(mrb, name);
if (!mrb_is_const_id(id)) {
//mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name));
}
if (mrb_const_defined_at(mrb, klass, id)) {
//mrb_warn("redefining constant Struct::%s", StringValuePtr(name));
mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name));
//?rb_mod_remove_const(klass, mrb_sym2name(mrb, id));
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_STRUCT);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_class_new_instance_m, ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_class_new_instance_m, ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, ARGS_NONE());
//RSTRUCT(nstr)->basic.c->super = c->c;
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
for (i=0; i< len; i++) {
mrb_sym id = SYM2ID(ptr_members[i]);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
if (i < N_REF_FUNC) {
mrb_define_method_id(mrb, c, id, (mrb_func_t)ref_func[i], 0);
}
else {
mrb_define_method_id(mrb, c, id, mrb_struct_ref, 0);
}
mrb_define_method_id(mrb, c, mrb_id_attrset(id), (mrb_func_t)mrb_struct_set, 1);
}
}
return nstr;
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr, *ptr_members;
mrb_sym id;
mrb_int i, len;
struct RClass *c;
int ai;
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_obj_to_sym(mrb, name);
if (!mrb_is_const_id(id)) {
mrb_name_error(mrb, id, "identifier %S needs to be constant", name);
}
if (mrb_const_defined_at(mrb, klass, id)) {
mrb_warn(mrb, "redefining constant Struct::%S", name);
/* ?rb_mod_remove_const(klass, mrb_sym2name(mrb, id)); */
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE());
/* RSTRUCT(nstr)->basic.c->super = c->c; */
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
ai = mrb_gc_arena_save(mrb);
for (i=0; i< len; i++) {
mrb_sym id = mrb_symbol(ptr_members[i]);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
if (i < N_REF_FUNC) {
mrb_define_method_id(mrb, c, id, ref_func[i], MRB_ARGS_NONE());
}
else {
mrb_define_method_id(mrb, c, id, mrb_struct_ref, MRB_ARGS_NONE());
}
mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, MRB_ARGS_REQ(1));
mrb_gc_arena_restore(mrb, ai);
}
}
return nstr;
}
static size_t
get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
{
size_t size = 0;
size_t pool_no;
int len;
mrb_value str;
char buf[32];
size += sizeof(uint32_t); /* plen */
size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
size += RSTRING_LEN(str);
break;
case MRB_TT_FLOAT:
len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no]));
size += len;
break;
case MRB_TT_STRING:
str = mrb_str_to_str(mrb, irep->pool[pool_no]);
size += RSTRING_LEN(str);
break;
default:
break;
}
mrb_gc_arena_restore(mrb, ai);
}
return size;
}
MRB_API mrb_value
mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
{
str = mrb_str_to_str(mrb, str);
return mrb_obj_new(mrb, c, 1, &str);
}
mrb_value
mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
{
const char *p, *end;
char *buf;
mrb_int blen;
mrb_int bsiz;
mrb_value result;
mrb_int n;
mrb_int width;
mrb_int prec;
int flags = FNONE;
int nextarg = 1;
int posarg = 0;
mrb_value nextvalue;
mrb_value str;
mrb_value hash = mrb_undef_value();
#define CHECK_FOR_WIDTH(f) \
if ((f) & FWIDTH) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice"); \
} \
if ((f) & FPREC0) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision"); \
}
#define CHECK_FOR_FLAGS(f) \
if ((f) & FWIDTH) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width"); \
} \
if ((f) & FPREC0) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision"); \
}
++argc;
--argv;
fmt = mrb_str_to_str(mrb, fmt);
p = RSTRING_PTR(fmt);
end = p + RSTRING_LEN(fmt);
blen = 0;
bsiz = 120;
result = mrb_str_buf_new(mrb, bsiz);
buf = RSTRING_PTR(result);
memset(buf, 0, bsiz);
for (; p < end; p++) {
const char *t;
mrb_sym id = 0;
for (t = p; t < end && *t != '%'; t++) ;
PUSH(p, t - p);
if (t >= end)
goto sprint_exit; /* end of fmt string */
p = t + 1; /* skip '%' */
width = prec = -1;
nextvalue = mrb_undef_value();
retry:
switch (*p) {
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - \\%%S", mrb_str_new(mrb, p, 1));
break;
case ' ':
CHECK_FOR_FLAGS(flags);
flags |= FSPACE;
p++;
goto retry;
case '#':
CHECK_FOR_FLAGS(flags);
flags |= FSHARP;
p++;
goto retry;
case '+':
CHECK_FOR_FLAGS(flags);
flags |= FPLUS;
p++;
goto retry;
case '-':
CHECK_FOR_FLAGS(flags);
flags |= FMINUS;
p++;
goto retry;
case '0':
CHECK_FOR_FLAGS(flags);
flags |= FZERO;
p++;
goto retry;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = 0;
GETNUM(n, width);
if (*p == '$') {
if (!mrb_undef_p(nextvalue)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %S$", mrb_fixnum_value(n));
}
nextvalue = GETPOSARG(n);
p++;
goto retry;
}
CHECK_FOR_WIDTH(flags);
width = n;
flags |= FWIDTH;
goto retry;
case '<':
case '{': {
const char *start = p;
char term = (*p == '<') ? '>' : '}';
mrb_value symname;
for (; p < end && *p != term; )
p++;
if (id) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%S after <%S>",
mrb_str_new(mrb, start, p - start + 1), mrb_sym2str(mrb, id));
}
symname = mrb_str_new(mrb, start + 1, p - start - 1);
id = mrb_intern_str(mrb, symname);
nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1));
if (mrb_undef_p(nextvalue)) {
mrb_raisef(mrb, E_KEY_ERROR, "key%S not found", mrb_str_new(mrb, start, p - start + 1));
}
if (term == '}') goto format_s;
p++;
goto retry;
}
case '*':
CHECK_FOR_WIDTH(flags);
flags |= FWIDTH;
GETASTER(width);
if (width < 0) {
flags |= FMINUS;
width = -width;
}
p++;
goto retry;
case '.':
if (flags & FPREC0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "precision given twice");
}
flags |= FPREC|FPREC0;
prec = 0;
p++;
if (*p == '*') {
GETASTER(prec);
if (prec < 0) { /* ignore negative precision */
flags &= ~FPREC;
}
p++;
goto retry;
}
GETNUM(prec, precision);
goto retry;
case '\n':
case '\0':
p--;
/* fallthrough */
case '%':
if (flags != FNONE) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %");
}
PUSH("%", 1);
break;
case 'c': {
mrb_value val = GETARG();
mrb_value tmp;
char *c;
tmp = mrb_check_string_type(mrb, val);
if (!mrb_nil_p(tmp)) {
if (mrb_fixnum(mrb_funcall(mrb, tmp, "size", 0)) != 1 ) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
}
}
else if (mrb_fixnum_p(val)) {
tmp = mrb_funcall(mrb, val, "chr", 0);
}
else {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
}
c = RSTRING_PTR(tmp);
n = RSTRING_LEN(tmp);
if (!(flags & FWIDTH)) {
CHECK(n);
memcpy(buf+blen, c, n);
blen += n;
}
else if ((flags & FMINUS)) {
CHECK(n);
memcpy(buf+blen, c, n);
blen += n;
FILL(' ', width-1);
}
else {
FILL(' ', width-1);
CHECK(n);
memcpy(buf+blen, c, n);
blen += n;
}
}
break;
case 's':
case 'p':
format_s:
{
mrb_value arg = GETARG();
mrb_int len;
mrb_int slen;
if (*p == 'p') arg = mrb_inspect(mrb, arg);
str = mrb_obj_as_string(mrb, arg);
len = RSTRING_LEN(str);
if (RSTRING(result)->flags & MRB_STR_EMBED) {
mrb_int tmp_n = len;
RSTRING(result)->flags &= ~MRB_STR_EMBED_LEN_MASK;
RSTRING(result)->flags |= tmp_n << MRB_STR_EMBED_LEN_SHIFT;
} else {
RSTRING(result)->as.heap.len = blen;
}
if (flags&(FPREC|FWIDTH)) {
slen = RSTRING_LEN(str);
if (slen < 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid mbstring sequence");
}
if ((flags&FPREC) && (prec < slen)) {
char *p = RSTRING_PTR(str) + prec;
slen = prec;
len = p - RSTRING_PTR(str);
}
/* need to adjust multi-byte string pos */
if ((flags&FWIDTH) && (width > slen)) {
width -= (int)slen;
if (!(flags&FMINUS)) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
CHECK(len);
memcpy(&buf[blen], RSTRING_PTR(str), len);
blen += len;
if (flags&FMINUS) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
break;
}
}
PUSH(RSTRING_PTR(str), len);
}
break;
case 'd':
case 'i':
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
case 'u': {
mrb_value val = GETARG();
char fbuf[32], nbuf[68], *s;
const char *prefix = NULL;
int sign = 0, dots = 0;
char sc = 0;
mrb_int v = 0;
int base;
mrb_int len;
switch (*p) {
case 'd':
case 'i':
case 'u':
sign = 1; break;
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
if (flags&(FPLUS|FSPACE)) sign = 1;
break;
default:
break;
}
if (flags & FSHARP) {
switch (*p) {
case 'o': prefix = "0"; break;
case 'x': prefix = "0x"; break;
case 'X': prefix = "0X"; break;
case 'b': prefix = "0b"; break;
case 'B': prefix = "0B"; break;
default: break;
}
}
bin_retry:
switch (mrb_type(val)) {
case MRB_TT_FLOAT:
val = mrb_flo_to_fixnum(mrb, val);
if (mrb_fixnum_p(val)) goto bin_retry;
break;
case MRB_TT_STRING:
val = mrb_str_to_inum(mrb, val, 0, TRUE);
goto bin_retry;
case MRB_TT_FIXNUM:
v = mrb_fixnum(val);
break;
default:
val = mrb_Integer(mrb, val);
goto bin_retry;
}
switch (*p) {
case 'o':
base = 8; break;
case 'x':
case 'X':
base = 16; break;
case 'b':
case 'B':
base = 2; break;
case 'u':
case 'd':
case 'i':
default:
base = 10; break;
}
if (base == 2) {
if (v < 0 && !sign) {
val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
dots = 1;
}
else {
val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
}
}
if (sign) {
char c = *p;
if (c == 'i') c = 'd'; /* %d and %i are identical */
if (v < 0) {
v = -v;
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
if (base == 2) {
snprintf(nbuf, sizeof(nbuf), "%s", RSTRING_PTR(val));
}
else {
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(nbuf, sizeof(nbuf), fbuf, v);
}
s = nbuf;
}
else {
char c = *p;
if (c == 'X') c = 'x';
s = nbuf;
if (v < 0) {
dots = 1;
}
if (base == 2) {
snprintf(++s, sizeof(nbuf) - 1, "%s", RSTRING_PTR(val));
}
else {
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(++s, sizeof(nbuf) - 1, fbuf, v);
}
if (v < 0) {
char d;
s = remove_sign_bits(s, base);
switch (base) {
case 16: d = 'f'; break;
case 8: d = '7'; break;
case 2: d = '1'; break;
default: d = 0; break;
}
if (d && *s != d) {
*--s = d;
}
}
}
{
size_t size;
size = strlen(s);
/* PARANOID: assert(size <= MRB_INT_MAX) */
len = (mrb_int)size;
}
if (dots) {
prec -= 2;
width -= 2;
}
if (*p == 'X') {
char *pp = s;
int c;
while ((c = (int)(unsigned char)*pp) != 0) {
*pp = toupper(c);
pp++;
}
}
if (prefix && !prefix[1]) { /* octal */
if (dots) {
prefix = NULL;
}
else if (len == 1 && *s == '0') {
len = 0;
if (flags & FPREC) prec--;
}
else if ((flags & FPREC) && (prec > len)) {
prefix = NULL;
}
}
else if (len == 1 && *s == '0') {
prefix = NULL;
}
if (prefix) {
size_t size;
size = strlen(prefix);
/* PARANOID: assert(size <= MRB_INT_MAX).
* this check is absolutely paranoid. */
width -= (mrb_int)size;
}
if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
prec = width;
width = 0;
}
else {
if (prec < len) {
if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
prec = len;
}
width -= prec;
}
if (!(flags&FMINUS)) {
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
if (sc) PUSH(&sc, 1);
if (prefix) {
int plen = (int)strlen(prefix);
PUSH(prefix, plen);
}
CHECK(prec - len);
if (dots) PUSH("..", 2);
if (v < 0) {
char c = sign_bits(base, p);
while (len < prec--) {
buf[blen++] = c;
}
}
else if ((flags & (FMINUS|FPREC)) != FMINUS) {
char c = '0';
while (len < prec--) {
buf[blen++] = c;
}
}
PUSH(s, len);
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
break;
case 'f':
case 'g':
case 'G':
case 'e':
case 'E':
case 'a':
case 'A': {
mrb_value val = GETARG();
double fval;
int i, need = 6;
char fbuf[32];
fval = mrb_float(mrb_Float(mrb, val));
if (!isfinite(fval)) {
const char *expr;
const int elen = 3;
if (isnan(fval)) {
expr = "NaN";
}
else {
expr = "Inf";
}
need = elen;
if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS))
need++;
if ((flags & FWIDTH) && need < width)
need = width;
CHECK(need + 1);
snprintf(&buf[blen], need + 1, "%*s", need, "");
if (flags & FMINUS) {
if (!isnan(fval) && fval < 0.0)
buf[blen++] = '-';
else if (flags & FPLUS)
buf[blen++] = '+';
else if (flags & FSPACE)
blen++;
memcpy(&buf[blen], expr, elen);
}
else {
if (!isnan(fval) && fval < 0.0)
buf[blen + need - elen - 1] = '-';
else if (flags & FPLUS)
buf[blen + need - elen - 1] = '+';
else if ((flags & FSPACE) && need > width)
blen++;
memcpy(&buf[blen + need - elen], expr, elen);
}
blen += strlen(&buf[blen]);
break;
}
fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
need = 0;
if (*p != 'e' && *p != 'E') {
i = INT_MIN;
frexp(fval, &i);
if (i > 0)
need = BIT_DIGITS(i);
}
need += (flags&FPREC) ? prec : 6;
if ((flags&FWIDTH) && need < width)
need = width;
need += 20;
CHECK(need);
n = snprintf(&buf[blen], need, fbuf, fval);
blen += n;
}
break;
}
flags = FNONE;
}
sprint_exit:
#if 0
/* XXX - We cannot validate the number of arguments if (digit)$ style used.
*/
if (posarg >= 0 && nextarg < argc) {
const char *mesg = "too many arguments for format string";
if (mrb_test(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
if (mrb_test(ruby_verbose)) mrb_warn(mrb, "%S", mrb_str_new_cstr(mrb, mesg));
}
#endif
mrb_str_resize(mrb, result, blen);
return result;
}
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->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->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->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),
on_connect);
ctx->refs.request = h2o_mruby_create_data_instance(mrb, mrb_ary_entry(generator->ctx->constants, H2O_MRUBY_HTTP_REQUEST_CLASS),
ctx, &request_type);
return ctx->refs.request;
}
mrb_value
mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
{
str = mrb_str_to_str(mrb, str);
return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str);
}
mrb_value mrb_exc_new_str(RClass* c, mrb_value str)
{
str = mrb_str_to_str(c->m_vm, str);
return c->m_vm->funcall(mrb_value::wrap(c), "new", 1, str);
}
