mrb_value
mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str)
{
//StringValue(str);
mrb_string_value(mrb, &str);
return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str);
}
static uint32_t
get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
{
uint32_t size = 0;
int pool_no;
mrb_value str;
char buf[32];
size += MRB_DUMP_SIZE_OF_LONG; /* plen */
size += irep->plen; /* tt(n) */
size += irep->plen * MRB_DUMP_SIZE_OF_SHORT; /* len(n) */
size += MRB_DUMP_SIZE_OF_SHORT; /* crc */
size = DUMP_SIZE(size, type);
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
uint16_t nlen =0;
int len;
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
len = mrb_int_to_str( buf, mrb_fixnum(irep->pool[pool_no]));
size += (uint32_t)len;
break;
case MRB_TT_FLOAT:
len = mrb_float_to_str( buf, mrb_float(irep->pool[pool_no]));
size += (uint32_t)len;
break;
case MRB_TT_STRING:
str = mrb_string_value( mrb, &irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
size += nlen;
break;
#ifdef ENABLE_REGEXP
case MRB_TT_REGEX:
str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
size += nlen;
break;
#endif
default:
break;
}
}
return size;
}
static uint32_t
get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
{
uint32_t size = 0;
int pool_no;
mrb_value str;
char buf[32];
size += MRB_DUMP_SIZE_OF_LONG; /* plen */
size += irep->plen * sizeof(char); /* tt(n) */
size += irep->plen * MRB_DUMP_SIZE_OF_SHORT; /* len(n) */
size += MRB_DUMP_SIZE_OF_SHORT; /* crc */
size = DUMP_SIZE(size, type);
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
uint16_t nlen =0;
switch (irep->pool[pool_no].tt) {
case MRB_TT_FIXNUM:
sprintf( buf, "%d", irep->pool[pool_no].value.i);
size += strlen(buf);
break;
case MRB_TT_FLOAT:
sprintf( buf, "%.16e", irep->pool[pool_no].value.f);
size += strlen(buf);
break;
case MRB_TT_STRING:
str = mrb_string_value( mrb, &irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
size += nlen;
break;
#ifdef INCLUDE_REGEXP
case MRB_TT_REGEX:
str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
size += nlen;
break;
#endif
default:
break;
}
}
return size;
}
static mrb_encoding *
to_encoding(mrb_state *mrb, mrb_value enc)
{
int idx;
//StringValue(enc);
mrb_string_value(mrb, &enc);
if (!mrb_enc_asciicompat(mrb, mrb_enc_get(mrb, enc))) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid name encoding (non ASCII)");
}
//idx = mrb_enc_find_index(StringValueCStr(enc));
idx = mrb_enc_find_index(mrb, mrb_string_value_cstr(mrb, &enc));
if (idx < 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "unknown encoding name - %s", RSTRING_PTR(enc));
}
return mrb_enc_from_index(mrb, idx);
}
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_fix2str(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_string_value(mrb, &irep->pool[pool_no]);
size += RSTRING_LEN(str);
break;
default:
break;
}
mrb_gc_arena_restore(mrb, ai);
}
return size;
}
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 tmp;
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;
mrb_string_value(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--;
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;
unsigned int c;
tmp = mrb_check_string_type(mrb, val);
if (!mrb_nil_p(tmp)) {
if (RSTRING_LEN(tmp) != 1 ) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
}
c = RSTRING_PTR(tmp)[0];
n = 1;
}
else {
c = mrb_fixnum(val);
n = 1;
}
if (n <= 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
}
if (!(flags & FWIDTH)) {
CHECK(n);
buf[blen] = c;
blen += n;
}
else if ((flags & FMINUS)) {
CHECK(n);
buf[blen] = c;
blen += n;
FILL(' ', width-1);
}
else {
FILL(' ', width-1);
CHECK(n);
buf[blen] = c;
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);
RSTRING_LEN(result) = 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[64], *s;
const char *prefix = NULL;
int sign = 0, dots = 0;
char sc = 0;
mrb_int v = 0, org_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:
if (FIXABLE(mrb_float(val))) {
val = mrb_fixnum_value((mrb_int)mrb_float(val));
goto bin_retry;
}
val = mrb_flt2big(mrb, mrb_float(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) {
org_v = v;
if ( v < 0 && !sign ) {
val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
dots = 1;
}
else {
val = mrb_fix2str(mrb, mrb_fixnum_value(v), base);
}
v = mrb_fixnum(mrb_str_to_inum(mrb, val, 10, 0/*Qfalse*/));
}
if (sign) {
char c = *p;
if (c == 'i') c = 'd'; /* %d and %i are identical */
if (base == 2) c = 'd';
if (v < 0) {
v = -v;
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(nbuf, sizeof(nbuf), fbuf, v);
s = nbuf;
}
else {
char c = *p;
if (c == 'X') c = 'x';
if (base == 2) c = 'd';
s = nbuf;
if (v < 0) {
dots = 1;
}
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 || (base == 2 && org_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 (isnan(fval) || isinf(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);
n = 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("%s", mesg);
}
#endif
mrb_str_resize(mrb, result, blen);
return result;
}
static int
write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
int pool_no;
mrb_value str;
char *buf_top = buf;
char *char_buf;
uint16_t buf_size =0;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
goto error_exit;
buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
uint16_t nlen =0;
buf += uint8_dump(irep->pool[pool_no].tt, buf, type); /* data type */
memset(char_buf, 0, buf_size);
switch (irep->pool[pool_no].tt) {
case MRB_TT_FIXNUM:
sprintf(char_buf, "%d", irep->pool[pool_no].value.i);
break;
case MRB_TT_FLOAT:
sprintf(char_buf, "%.16e", irep->pool[pool_no].value.f);
break;
case MRB_TT_STRING:
str = mrb_string_value( mrb, &irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
goto error_exit;
memset(char_buf, 0, buf_size);
}
str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
break;
#ifdef INCLUDE_REGEXP
case MRB_TT_REGEX:
str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
goto error_exit;
memset(char_buf, 0, buf_size);
}
str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
break;
#endif
default:
buf += uint16_dump(0, buf, type); /* data length = 0 */
continue;
}
buf += uint16_dump((uint16_t)strlen(char_buf), buf, type); /* data length */
memcpy(buf, char_buf, strlen(char_buf));
buf += strlen(char_buf);
}
error_exit:
if (char_buf)
mrb_free(mrb, char_buf);
return (int)(buf - buf_top);
}
