#include "mruby.h"

#ifdef ENABLE_SPRINTF

#include <stdio.h>

#include <string.h>

#include "encoding.h"

#include "mruby/string.h"

#include "mruby/hash.h"

#include "mruby/numeric.h"

#include <math.h>

#include <ctype.h>

#ifdef HAVE_IEEEFP_H

#include <ieeefp.h>

#define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */

#define BITSPERDIG (sizeof(mrb_int)*CHAR_BIT)

#define EXTENDSIGN(n, l) (((~0 << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0 << (n)))

static void fmt_setup(char*,size_t,int,int,int,int);

static char*

remove_sign_bits(char *str, int base)

{

char *t;

t = str;

if (base == 16) {

while (*t == 'f') {

t++;

}

}

else if (base == 8) {

*t |= EXTENDSIGN(3, strlen(t));

while (*t == '7') {

t++;

}

}

else if (base == 2) {

while (*t == '1') {

t++;

}

}

return t;

}

static char

sign_bits(int base, const char *p)

{

char c;

switch (base) {

case 16:

if (*p == 'X') c = 'F';

else c = 'f';

break;

case 8:

c = '7'; break;

case 2:

c = '1'; break;

default:

c = '.'; break;

}

return c;

}

static mrb_value

mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)

{

char buf[64], *b = buf + sizeof buf;

unsigned long val = mrb_fixnum(x);

char d;

if (base != 2) {

mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);

}

if (val >= (1 << 10))

val &= 0x3ff;

if (val == 0) {

return mrb_str_new(mrb, "0", 1);

}

*--b = '\0';

do {

*--b = mrb_digitmap[(int)(val % base)];

} while (val /= base);

if (mrb_fixnum(x) < 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_new2(mrb, b);

}

#define FNONE 0

#define FSHARP 1

#define FMINUS 2

#define FPLUS 4

#define FZERO 8

#define FSPACE 16

#define FWIDTH 32

#define FPREC 64

#define FPREC0 128

#define CHECK(l) do {\

/* int cr = ENC_CODERANGE(result);*/\

while (blen + (l) >= bsiz) {\

bsiz*=2;\

}\

mrb_str_resize(mrb, result, bsiz);\

/* ENC_CODERANGE_SET(result, cr);*/\

buf = RSTRING_PTR(result);\

} while (0)

#define PUSH(s, l) do { \

CHECK(l);\

memcpy(&buf[blen], s, l);\

blen += (l);\

} while (0)

#define FILL(c, l) do { \

CHECK(l);\

memset(&buf[blen], c, l);\

blen += (l);\

} while (0)

#define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : \

posarg == -1 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \

posarg == -2 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg), mrb_undef_value()) : \

(posarg = nextarg++, GETNTHARG(posarg)))

#define GETPOSARG(n) (posarg > 0 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after unnumbered(%d)", n, posarg), mrb_undef_value()) : \

posarg == -2 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after named", n), mrb_undef_value()) : \

((n < 1) ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %d$", n), mrb_undef_value()) : \

(posarg = -1, GETNTHARG(n))))

#define GETNTHARG(nth) \

((nth >= argc) ? (mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments"), mrb_undef_value()) : argv[nth])

#define GETNAMEARG(id, name, len) ( \

posarg > 0 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \

posarg == -1 ? \

(mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) : \

(posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))

#define GETNUM(n, val) \

for (; p < end && ISDIGIT(*p); p++) {\

int next_n = 10 * n + (*p - '0'); \

if (next_n / 10 != n) {\

mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \

} \

n = next_n; \

} \

if (p >= end) { \

mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \

}

#define GETASTER(num) do { \

t = p++; \

n = 0; \

GETNUM(n, val); \

if (*p == '$') { \

tmp = GETPOSARG(n); \

} \

else { \

tmp = GETARG(); \

p = t; \

} \

num = mrb_fixnum(tmp); \

} while (0)

static mrb_value

get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)

{

mrb_value tmp;

if (!mrb_undef_p(*hash)) return *hash;

if (argc != 2) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");

}

tmp = mrb_check_convert_type(mrb, argv[1], MRB_TT_HASH, "Hash", "to_hash");

if (mrb_nil_p(tmp)) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");

}

return (*hash = tmp);

}

mrb_f_sprintf(mrb_state *mrb, mrb_value obj)

{

int argc;

mrb_value *argv;

mrb_get_args(mrb, "*", &argv, &argc);

if (argc <= 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments");

return mrb_nil_value();

}

else {

return mrb_str_format(mrb, argc - 1, argv + 1, argv[0]);

}

}

mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)

{

const char *p, *end;

char *buf;

long blen, bsiz;

mrb_value result;

int n;

int width, prec, 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 - %%%c", *p);

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 - %d$", 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>",

(int)(p - start + 1), start, mrb_sym2name(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", (int)(p - start + 1), start);

}

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();

long len, 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 = 0;

int sign = 0, dots = 0;

char sc = 0;

long v = 0, org_v = 0;

int base;

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 = (long)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;

}

}

}

len = (int)strlen(s);

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 = 0;

}

else if (len == 1 && *s == '0') {

len = 0;

if (flags & FPREC) prec--;

}

else if ((flags & FPREC) && (prec > len)) {

prefix = 0;

}

}

else if (len == 1 && *s == '0') {

prefix = 0;

}

if (prefix) {

width -= (int)strlen(prefix);

}

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++;