sprintf.c

   1 /**********************************************************************
   2
   3   sprintf.c -
   4
   5   $Author$
   6   created at: Fri Oct 15 10:39:26 JST 1993
   7
   8   Copyright (C) 1993-2007 Yukihiro Matsumoto
   9   Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
  10   Copyright (C) 2000  Information-technology Promotion Agency, Japan
  11
  12 **********************************************************************/
  13
  14 #include "ruby/internal/config.h"
  15
  16 #include <math.h>
  17 #include <stdarg.h>
  18
  19 #ifdef HAVE_IEEEFP_H
  20 # include <ieeefp.h>
  21 #endif
  22
  23 #include "id.h"
  24 #include "internal.h"
  25 #include "internal/error.h"
  26 #include "internal/hash.h"
  27 #include "internal/numeric.h"
  28 #include "internal/object.h"
  29 #include "internal/sanitizers.h"
  30 #include "internal/symbol.h"
  31 #include "ruby/encoding.h"
  32 #include "ruby/re.h"
  33 #include "ruby/util.h"
  34
  35 #define BIT_DIGITS(N)   (((N)*146)/485 + 1)  /* log2(10) =~ 146/485 */
  36
  37 static char *fmt_setup(char*,size_t,int,int,int,int);
  38 static char *ruby_ultoa(unsigned long val, char *endp, int base, int octzero);
  39
  40 static char
  41 sign_bits(int base, const char *p)
  42 {
  43     char c = '.';
  44
  45     switch (base) {
  46       case 16:
  47         if (*p == 'X') c = 'F';
  48         else c = 'f';
  49         break;
  50       case 8:
  51         c = '7'; break;
  52       case 2:
  53         c = '1'; break;
  54     }
  55     return c;
  56 }
  57
  58 #define FNONE  0
  59 #define FSHARP 1
  60 #define FMINUS 2
  61 #define FPLUS  4
  62 #define FZERO  8
  63 #define FSPACE 16
  64 #define FWIDTH 32
  65 #define FPREC  64
  66 #define FPREC0 128
  67
  68 #define CHECK(l) do {\
  69     int cr = ENC_CODERANGE(result);\
  70     while ((l) >= bsiz - blen) {\
  71         bsiz*=2;\
  72         if (bsiz<0) rb_raise(rb_eArgError, "too big specifier");\
  73     }\
  74     rb_str_resize(result, bsiz);\
  75     ENC_CODERANGE_SET(result, cr);\
  76     buf = RSTRING_PTR(result);\
  77 } while (0)
  78
  79 #define PUSH(s, l) do { \
  80     CHECK(l);\
  81     PUSH_(s, l);\
  82 } while (0)
  83
  84 #define PUSH_(s, l) do { \
  85     memcpy(&buf[blen], (s), (l));\
  86     blen += (l);\
  87 } while (0)
  88
  89 #define FILL(c, l) do { \
  90     if ((l) <= 0) break;\
  91     CHECK(l);\
  92     FILL_(c, l);\
  93 } while (0)
  94
  95 #define FILL_(c, l) do { \
  96     memset(&buf[blen], (c), (l));\
  97     blen += (l);\
  98 } while (0)
  99
 100 #define GETARG() (!UNDEF_P(nextvalue) ? nextvalue : \
 101                   GETNEXTARG())
 102
 103 #define GETNEXTARG() ( \
 104     check_next_arg(posarg, nextarg), \
 105     (posarg = nextarg++, GETNTHARG(posarg)))
 106
 107 #define GETPOSARG(n) ( \
 108     check_pos_arg(posarg, (n)), \
 109     (posarg = -1, GETNTHARG(n)))
 110
 111 #define GETNTHARG(nth) \
 112     (((nth) >= argc) ? (rb_raise(rb_eArgError, "too few arguments"), 0) : argv[(nth)])
 113
 114 #define CHECKNAMEARG(name, len, enc) ( \
 115     check_name_arg(posarg, name, len, enc), \
 116     posarg = -2)
 117
 118 #define GETNUM(n, val) \
 119     (!(p = get_num(p, end, enc, &(n))) ? \
 120      rb_raise(rb_eArgError, #val " too big") : (void)0)
 121
 122 #define GETASTER(val) do { \
 123     t = p++; \
 124     n = 0; \
 125     GETNUM(n, val); \
 126     if (*p == '$') { \
 127         tmp = GETPOSARG(n); \
 128     } \
 129     else { \
 130         tmp = GETNEXTARG(); \
 131         p = t; \
 132     } \
 133     (val) = NUM2INT(tmp); \
 134 } while (0)
 135
 136 static const char *
 137 get_num(const char *p, const char *end, rb_encoding *enc, int *valp)
 138 {
 139     int next_n = *valp;
 140     for (; p < end && rb_enc_isdigit(*p, enc); p++) {
 141         if (MUL_OVERFLOW_INT_P(10, next_n))
 142             return NULL;
 143         next_n *= 10;
 144         if (INT_MAX - (*p - '0') < next_n)
 145             return NULL;
 146         next_n += *p - '0';
 147     }
 148     if (p >= end) {
 149         rb_raise(rb_eArgError, "malformed format string - %%*[0-9]");
 150     }
 151     *valp = next_n;
 152     return p;
 153 }
 154
 155 static void
 156 check_next_arg(int posarg, int nextarg)
 157 {
 158     switch (posarg) {
 159       case -1:
 160         rb_raise(rb_eArgError, "unnumbered(%d) mixed with numbered", nextarg);
 161       case -2:
 162         rb_raise(rb_eArgError, "unnumbered(%d) mixed with named", nextarg);
 163     }
 164 }
 165
 166 static void
 167 check_pos_arg(int posarg, int n)
 168 {
 169     if (posarg > 0) {
 170         rb_raise(rb_eArgError, "numbered(%d) after unnumbered(%d)", n, posarg);
 171     }
 172     if (posarg == -2) {
 173         rb_raise(rb_eArgError, "numbered(%d) after named", n);
 174     }
 175     if (n < 1) {
 176         rb_raise(rb_eArgError, "invalid index - %d$", n);
 177     }
 178 }
 179
 180 static void
 181 check_name_arg(int posarg, const char *name, int len, rb_encoding *enc)
 182 {
 183     if (posarg > 0) {
 184         rb_enc_raise(enc, rb_eArgError, "named%.*s after unnumbered(%d)", len, name, posarg);
 185     }
 186     if (posarg == -1) {
 187         rb_enc_raise(enc, rb_eArgError, "named%.*s after numbered", len, name);
 188     }
 189 }
 190
 191 static VALUE
 192 get_hash(volatile VALUE *hash, int argc, const VALUE *argv)
 193 {
 194     VALUE tmp;
 195
 196     if (!UNDEF_P(*hash)) return *hash;
 197     if (argc != 2) {
 198         rb_raise(rb_eArgError, "one hash required");
 199     }
 200     tmp = rb_check_hash_type(argv[1]);
 201     if (NIL_P(tmp)) {
 202         rb_raise(rb_eArgError, "one hash required");
 203     }
 204     return (*hash = tmp);
 205 }
 206
 207 VALUE
 208 rb_f_sprintf(int argc, const VALUE *argv)
 209 {
 210     return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
 211 }
 212
 213 VALUE
 214 rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 215 {
 216     enum {default_float_precision = 6};
 217     rb_encoding *enc;
 218     const char *p, *end;
 219     char *buf;
 220     long blen, bsiz;
 221     VALUE result;
 222
 223     long scanned = 0;
 224     enum ruby_coderange_type coderange = ENC_CODERANGE_7BIT;
 225     int width, prec, flags = FNONE;
 226     int nextarg = 1;
 227     int posarg = 0;
 228     VALUE nextvalue;
 229     VALUE tmp;
 230     VALUE orig;
 231     VALUE str;
 232     volatile VALUE hash = Qundef;
 233
 234 #define CHECK_FOR_WIDTH(f)                               \
 235     if ((f) & FWIDTH) {                                  \
 236         rb_raise(rb_eArgError, "width given twice");     \
 237     }                                                    \
 238     if ((f) & FPREC0) {                                  \
 239         rb_raise(rb_eArgError, "width after precision"); \
 240     }
 241 #define CHECK_FOR_FLAGS(f)                               \
 242     if ((f) & FWIDTH) {                                  \
 243         rb_raise(rb_eArgError, "flag after width");      \
 244     }                                                    \
 245     if ((f) & FPREC0) {                                  \
 246         rb_raise(rb_eArgError, "flag after precision"); \
 247     }
 248
 249 #define update_coderange(partial) do { \
 250         if (coderange != ENC_CODERANGE_BROKEN && scanned < blen \
 251             && rb_enc_to_index(enc) /* != ENCINDEX_ASCII_8BIT */) { \
 252             int cr = coderange; \
 253             scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr); \
 254             ENC_CODERANGE_SET(result, \
 255                               (partial && cr == ENC_CODERANGE_UNKNOWN ? \
 256                                ENC_CODERANGE_BROKEN : (coderange = cr))); \
 257         } \
 258     } while (0)
 259     ++argc;
 260     --argv;
 261     StringValue(fmt);
 262     enc = rb_enc_get(fmt);
 263     rb_must_asciicompat(fmt);
 264     orig = fmt;
 265     fmt = rb_str_tmp_frozen_acquire(fmt);
 266     p = RSTRING_PTR(fmt);
 267     end = p + RSTRING_LEN(fmt);
 268     blen = 0;
 269     bsiz = 120;
 270     result = rb_str_buf_new(bsiz);
 271     rb_enc_associate(result, enc);
 272     buf = RSTRING_PTR(result);
 273     memset(buf, 0, bsiz);
 274     ENC_CODERANGE_SET(result, coderange);
 275
 276     for (; p < end; p++) {
 277         const char *t;
 278         int n;
 279         VALUE sym = Qnil;
 280
 281         for (t = p; t < end && *t != '%'; t++) ;
 282         if (t + 1 == end) {
 283             rb_raise(rb_eArgError, "incomplete format specifier; use %%%% (double %%) instead");
 284         }
 285         PUSH(p, t - p);
 286         update_coderange(FALSE);
 287         if (t >= end) {
 288             /* end of fmt string */
 289             goto sprint_exit;
 290         }
 291         p = t + 1;              /* skip `%' */
 292
 293         width = prec = -1;
 294         nextvalue = Qundef;
 295       retry:
 296         switch (*p) {
 297           default:
 298             if (rb_enc_isprint(*p, enc))
 299                 rb_raise(rb_eArgError, "malformed format string - %%%c", *p);
 300             else
 301                 rb_raise(rb_eArgError, "malformed format string");
 302             break;
 303
 304           case ' ':
 305             CHECK_FOR_FLAGS(flags);
 306             flags |= FSPACE;
 307             p++;
 308             goto retry;
 309
 310           case '#':
 311             CHECK_FOR_FLAGS(flags);
 312             flags |= FSHARP;
 313             p++;
 314             goto retry;
 315
 316           case '+':
 317             CHECK_FOR_FLAGS(flags);
 318             flags |= FPLUS;
 319             p++;
 320             goto retry;
 321
 322           case '-':
 323             CHECK_FOR_FLAGS(flags);
 324             flags |= FMINUS;
 325             p++;
 326             goto retry;
 327
 328           case '0':
 329             CHECK_FOR_FLAGS(flags);
 330             flags |= FZERO;
 331             p++;
 332             goto retry;
 333
 334           case '1': case '2': case '3': case '4':
 335           case '5': case '6': case '7': case '8': case '9':
 336             n = 0;
 337             GETNUM(n, width);
 338             if (*p == '$') {
 339                 if (!UNDEF_P(nextvalue)) {
 340                     rb_raise(rb_eArgError, "value given twice - %d$", n);
 341                 }
 342                 nextvalue = GETPOSARG(n);
 343                 p++;
 344                 goto retry;
 345             }
 346             CHECK_FOR_WIDTH(flags);
 347             width = n;
 348             flags |= FWIDTH;
 349             goto retry;
 350
 351           case '<':
 352           case '{':
 353             {
 354                 const char *start = p;
 355                 char term = (*p == '<') ? '>' : '}';
 356                 int len;
 357
 358                 for (; p < end && *p != term; ) {
 359                     p += rb_enc_mbclen(p, end, enc);
 360                 }
 361                 if (p >= end) {
 362                     rb_raise(rb_eArgError, "malformed name - unmatched parenthesis");
 363                 }
 364 #if SIZEOF_INT < SIZEOF_SIZE_T
 365                 if ((size_t)(p - start) >= INT_MAX) {
 366                     const int message_limit = 20;
 367                     len = (int)(rb_enc_right_char_head(start, start + message_limit, p, enc) - start);
 368                     rb_enc_raise(enc, rb_eArgError,
 369                                  "too long name (%"PRIuSIZE" bytes) - %.*s...%c",
 370                                  (size_t)(p - start - 2), len, start, term);
 371                 }
 372 #endif
 373                 len = (int)(p - start + 1); /* including parenthesis */
 374                 if (sym != Qnil) {
 375                     rb_enc_raise(enc, rb_eArgError, "named%.*s after <%"PRIsVALUE">",
 376                                  len, start, rb_sym2str(sym));
 377                 }
 378                 CHECKNAMEARG(start, len, enc);
 379                 get_hash(&hash, argc, argv);
 380                 sym = rb_check_symbol_cstr(start + 1,
 381                                            len - 2 /* without parenthesis */,
 382                                            enc);
 383                 if (!NIL_P(sym)) nextvalue = rb_hash_lookup2(hash, sym, Qundef);
 384                 if (UNDEF_P(nextvalue)) {
 385                     if (NIL_P(sym)) {
 386                         sym = rb_sym_intern(start + 1,
 387                                             len - 2 /* without parenthesis */,
 388                                             enc);
 389                     }
 390                     nextvalue = rb_hash_default_value(hash, sym);
 391                     if (NIL_P(nextvalue)) {
 392                         rb_key_err_raise(rb_enc_sprintf(enc, "key%.*s not found", len, start), hash, sym);
 393                     }
 394                 }
 395                 if (term == '}') goto format_s;
 396                 p++;
 397                 goto retry;
 398             }
 399
 400           case '*':
 401             CHECK_FOR_WIDTH(flags);
 402             flags |= FWIDTH;
 403             GETASTER(width);
 404             if (width < 0) {
 405                 flags |= FMINUS;
 406                 width = -width;
 407                 if (width < 0) rb_raise(rb_eArgError, "width too big");
 408             }
 409             p++;
 410             goto retry;
 411
 412           case '.':
 413             if (flags & FPREC0) {
 414                 rb_raise(rb_eArgError, "precision given twice");
 415             }
 416             flags |= FPREC|FPREC0;
 417
 418             prec = 0;
 419             p++;
 420             if (*p == '*') {
 421                 GETASTER(prec);
 422                 if (prec < 0) { /* ignore negative precision */
 423                     flags &= ~FPREC;
 424                 }
 425                 p++;
 426                 goto retry;
 427             }
 428
 429             GETNUM(prec, precision);
 430             goto retry;
 431
 432           case '\n':
 433           case '\0':
 434             p--;
 435             /* fall through */
 436           case '%':
 437             if (flags != FNONE) {
 438                 rb_raise(rb_eArgError, "invalid format character - %%");
 439             }
 440             PUSH("%", 1);
 441             break;
 442
 443           case 'c':
 444             {
 445                 VALUE val = GETARG();
 446                 VALUE tmp;
 447                 unsigned int c;
 448                 int n;
 449
 450                 tmp = rb_check_string_type(val);
 451                 if (!NIL_P(tmp)) {
 452                     flags |= FPREC;
 453                     prec = 1;
 454                     str = tmp;
 455                     goto format_s1;
 456                 }
 457                 n = NUM2INT(val);
 458                 if (n >= 0) n = rb_enc_codelen((c = n), enc);
 459                 if (n <= 0) {
 460                     rb_raise(rb_eArgError, "invalid character");
 461                 }
 462                 int encidx = rb_ascii8bit_appendable_encoding_index(enc, c);
 463                 if (encidx >= 0 && encidx != rb_enc_to_index(enc)) {
 464                     /* special case */
 465                     rb_enc_associate_index(result, encidx);
 466                     enc = rb_enc_from_index(encidx);
 467                     coderange = ENC_CODERANGE_VALID;
 468                 }
 469                 if (!(flags & FWIDTH)) {
 470                     CHECK(n);
 471                     rb_enc_mbcput(c, &buf[blen], enc);
 472                     blen += n;
 473                 }
 474                 else if ((flags & FMINUS)) {
 475                     --width;
 476                     CHECK(n + (width > 0 ? width : 0));
 477                     rb_enc_mbcput(c, &buf[blen], enc);
 478                     blen += n;
 479                     if (width > 0) FILL_(' ', width);
 480                 }
 481                 else {
 482                     --width;
 483                     CHECK(n + (width > 0 ? width : 0));
 484                     if (width > 0) FILL_(' ', width);
 485                     rb_enc_mbcput(c, &buf[blen], enc);
 486                     blen += n;
 487                 }
 488             }
 489             break;
 490
 491           case 's':
 492           case 'p':
 493           format_s:
 494             {
 495                 VALUE arg = GETARG();
 496                 long len, slen;
 497
 498                 if (*p == 'p') {
 499                     str = rb_inspect(arg);
 500                 }
 501                 else {
 502                     str = rb_obj_as_string(arg);
 503                 }
 504               format_s1:
 505                 len = RSTRING_LEN(str);
 506                 rb_str_set_len(result, blen);
 507                 update_coderange(TRUE);
 508                 enc = rb_enc_check(result, str);
 509                 if (flags&(FPREC|FWIDTH)) {
 510                     slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc);
 511                     if (slen < 0) {
 512                         rb_raise(rb_eArgError, "invalid mbstring sequence");
 513                     }
 514                     if ((flags&FPREC) && (prec < slen)) {
 515                         char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
 516                                              prec, enc);
 517                         slen = prec;
 518                         len = p - RSTRING_PTR(str);
 519                     }
 520                     /* need to adjust multi-byte string pos */
 521                     if ((flags&FWIDTH) && (width > slen)) {
 522                         width -= (int)slen;
 523                         CHECK(len + width);
 524                         if (!(flags&FMINUS)) {
 525                             FILL_(' ', width);
 526                             width = 0;
 527                         }
 528                         memcpy(&buf[blen], RSTRING_PTR(str), len);
 529                         RB_GC_GUARD(str);
 530                         blen += len;
 531                         if (flags&FMINUS) {
 532                             FILL_(' ', width);
 533                         }
 534                         rb_enc_associate(result, enc);
 535                         break;
 536                     }
 537                 }
 538                 PUSH(RSTRING_PTR(str), len);
 539                 RB_GC_GUARD(str);
 540                 rb_enc_associate(result, enc);
 541             }
 542             break;
 543
 544           case 'd':
 545           case 'i':
 546           case 'o':
 547           case 'x':
 548           case 'X':
 549           case 'b':
 550           case 'B':
 551           case 'u':
 552             {
 553                 volatile VALUE val = GETARG();
 554                 int valsign;
 555                 char nbuf[BIT_DIGITS(SIZEOF_LONG*CHAR_BIT)+2], *s;
 556                 const char *prefix = 0;
 557                 int sign = 0, dots = 0;
 558                 char sc = 0;
 559                 long v = 0;
 560                 int base, bignum = 0;
 561                 int len;
 562
 563                 switch (*p) {
 564                   case 'd':
 565                   case 'i':
 566                   case 'u':
 567                     sign = 1; break;
 568                   case 'o':
 569                   case 'x':
 570                   case 'X':
 571                   case 'b':
 572                   case 'B':
 573                     if (flags&(FPLUS|FSPACE)) sign = 1;
 574                     break;
 575                 }
 576                 if (flags & FSHARP) {
 577                     switch (*p) {
 578                       case 'o':
 579                         prefix = "0"; break;
 580                       case 'x':
 581                         prefix = "0x"; break;
 582                       case 'X':
 583                         prefix = "0X"; break;
 584                       case 'b':
 585                         prefix = "0b"; break;
 586                       case 'B':
 587                         prefix = "0B"; break;
 588                     }
 589                 }
 590
 591               bin_retry:
 592                 switch (TYPE(val)) {
 593                   case T_FLOAT:
 594                     if (FIXABLE(RFLOAT_VALUE(val))) {
 595                         val = LONG2FIX((long)RFLOAT_VALUE(val));
 596                         goto bin_retry;
 597                     }
 598                     val = rb_dbl2big(RFLOAT_VALUE(val));
 599                     if (FIXNUM_P(val)) goto bin_retry;
 600                     bignum = 1;
 601                     break;
 602                   case T_STRING:
 603                     val = rb_str_to_inum(val, 0, TRUE);
 604                     goto bin_retry;
 605                   case T_BIGNUM:
 606                     bignum = 1;
 607                     break;
 608                   case T_FIXNUM:
 609                     v = FIX2LONG(val);
 610                     break;
 611                   default:
 612                     val = rb_Integer(val);
 613                     goto bin_retry;
 614                 }
 615
 616                 switch (*p) {
 617                   case 'o':
 618                     base = 8; break;
 619                   case 'x':
 620                   case 'X':
 621                     base = 16; break;
 622                   case 'b':
 623                   case 'B':
 624                     base = 2; break;
 625                   case 'u':
 626                   case 'd':
 627                   case 'i':
 628                   default:
 629                     base = 10; break;
 630                 }
 631
 632                 if (base != 10) {
 633                     int numbits = ffs(base)-1;
 634                     size_t abs_nlz_bits;
 635                     size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits);
 636                     long i;
 637                     if (INT_MAX-1 < numdigits) /* INT_MAX is used because rb_long2int is used later. */
 638                         rb_raise(rb_eArgError, "size too big");
 639                     if (sign) {
 640                         if (numdigits == 0)
 641                             numdigits = 1;
 642                         tmp = rb_str_new(NULL, numdigits);
 643                         valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
 644                                 1, CHAR_BIT-numbits, INTEGER_PACK_BIG_ENDIAN);
 645                         for (i = 0; i < RSTRING_LEN(tmp); i++)
 646                             RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
 647                         s = RSTRING_PTR(tmp);
 648                         if (valsign < 0) {
 649                             sc = '-';
 650                             width--;
 651                         }
 652                         else if (flags & FPLUS) {
 653                             sc = '+';
 654                             width--;
 655                         }
 656                         else if (flags & FSPACE) {
 657                             sc = ' ';
 658                             width--;
 659                         }
 660                     }
 661                     else {
 662                         /* Following conditional "numdigits++" guarantees the
 663                          * most significant digit as
 664                          * - '1'(bin), '7'(oct) or 'f'(hex) for negative numbers
 665                          * - '0' for zero
 666                          * - not '0' for positive numbers.
 667                          *
 668                          * It also guarantees the most significant two
 669                          * digits will not be '11'(bin), '77'(oct), 'ff'(hex)
 670                          * or '00'.  */
 671                         if (numdigits == 0 ||
 672                                 ((abs_nlz_bits != (size_t)(numbits-1) ||
 673                                   !rb_absint_singlebit_p(val)) &&
 674                                  (!bignum ? v < 0 : BIGNUM_NEGATIVE_P(val))))
 675                             numdigits++;
 676                         tmp = rb_str_new(NULL, numdigits);
 677                         valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
 678                                 1, CHAR_BIT-numbits, INTEGER_PACK_2COMP | INTEGER_PACK_BIG_ENDIAN);
 679                         for (i = 0; i < RSTRING_LEN(tmp); i++)
 680                             RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
 681                         s = RSTRING_PTR(tmp);
 682                         dots = valsign < 0;
 683                     }
 684                     len = rb_long2int(RSTRING_END(tmp) - s);
 685                 }
 686                 else if (!bignum) {
 687                     valsign = 1;
 688                     if (v < 0) {
 689                         v = -v;
 690                         sc = '-';
 691                         width--;
 692                         valsign = -1;
 693                     }
 694                     else if (flags & FPLUS) {
 695                         sc = '+';
 696                         width--;
 697                     }
 698                     else if (flags & FSPACE) {
 699                         sc = ' ';
 700                         width--;
 701                     }
 702                     s = ruby_ultoa((unsigned long)v, nbuf + sizeof(nbuf), 10, 0);
 703                     len = (int)(nbuf + sizeof(nbuf) - s);
 704                 }
 705                 else {
 706                     tmp = rb_big2str(val, 10);
 707                     s = RSTRING_PTR(tmp);
 708                     valsign = 1;
 709                     if (s[0] == '-') {
 710                         s++;
 711                         sc = '-';
 712                         width--;
 713                         valsign = -1;
 714                     }
 715                     else if (flags & FPLUS) {
 716                         sc = '+';
 717                         width--;
 718                     }
 719                     else if (flags & FSPACE) {
 720                         sc = ' ';
 721                         width--;
 722                     }
 723                     len = rb_long2int(RSTRING_END(tmp) - s);
 724                 }
 725
 726                 if (dots) {
 727                     prec -= 2;
 728                     width -= 2;
 729                 }
 730
 731                 if (*p == 'X') {
 732                     char *pp = s;
 733                     int c;
 734                     while ((c = (int)(unsigned char)*pp) != 0) {
 735                         *pp = rb_enc_toupper(c, enc);
 736                         pp++;
 737                     }
 738                 }
 739                 if (prefix && !prefix[1]) { /* octal */
 740                     if (dots) {
 741                         prefix = 0;
 742                     }
 743                     else if (len == 1 && *s == '0') {
 744                         len = 0;
 745                         if (flags & FPREC) prec--;
 746                     }
 747                     else if ((flags & FPREC) && (prec > len)) {
 748                         prefix = 0;
 749                     }
 750                 }
 751                 else if (len == 1 && *s == '0') {
 752                     prefix = 0;
 753                 }
 754                 if (prefix) {
 755                     width -= (int)strlen(prefix);
 756                 }
 757                 if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
 758                     prec = width;
 759                     width = 0;
 760                 }
 761                 else {
 762                     if (prec < len) {
 763                         if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
 764                         prec = len;
 765                     }
 766                     width -= prec;
 767                 }
 768                 if (!(flags&FMINUS)) {
 769                     FILL(' ', width);
 770                     width = 0;
 771                 }
 772                 if (sc) PUSH(&sc, 1);
 773                 if (prefix) {
 774                     int plen = (int)strlen(prefix);
 775                     PUSH(prefix, plen);
 776                 }
 777                 if (dots) PUSH("..", 2);
 778                 if (prec > len) {
 779                     CHECK(prec - len);
 780                     if (!sign && valsign < 0) {
 781                         char c = sign_bits(base, p);
 782                         FILL_(c, prec - len);
 783                     }
 784                     else if ((flags & (FMINUS|FPREC)) != FMINUS) {
 785                         FILL_('0', prec - len);
 786                     }
 787                 }
 788                 PUSH(s, len);
 789                 RB_GC_GUARD(tmp);
 790                 FILL(' ', width);
 791             }
 792             break;
 793
 794           case 'f':
 795             {
 796                 VALUE val = GETARG(), num, den;
 797                 int sign = (flags&FPLUS) ? 1 : 0, zero = 0;
 798                 long len, fill;
 799                 if (RB_INTEGER_TYPE_P(val)) {
 800                     den = INT2FIX(1);
 801                     num = val;
 802                 }
 803                 else if (RB_TYPE_P(val, T_RATIONAL)) {
 804                     den = rb_rational_den(val);
 805                     num = rb_rational_num(val);
 806                 }
 807                 else {
 808                     nextvalue = val;
 809                     goto float_value;
 810                 }
 811                 if (!(flags&FPREC)) prec = default_float_precision;
 812                 if (FIXNUM_P(num)) {
 813                     if ((SIGNED_VALUE)num < 0) {
 814                         long n = -FIX2LONG(num);
 815                         num = LONG2FIX(n);
 816                         sign = -1;
 817                     }
 818                 }
 819                 else if (BIGNUM_NEGATIVE_P(num)) {
 820                     sign = -1;
 821                     num = rb_big_uminus(num);
 822                 }
 823                 if (den != INT2FIX(1)) {
 824                     num = rb_int_mul(num, rb_int_positive_pow(10, prec));
 825                     num = rb_int_plus(num, rb_int_idiv(den, INT2FIX(2)));
 826                     num = rb_int_idiv(num, den);
 827                 }
 828                 else if (prec >= 0) {
 829                     zero = prec;
 830                 }
 831                 val = rb_int2str(num, 10);
 832                 len = RSTRING_LEN(val) + zero;
 833                 if (prec >= len) len = prec + 1; /* integer part 0 */
 834                 if (sign || (flags&FSPACE)) ++len;
 835                 if (prec > 0) ++len; /* period */
 836                 fill = width > len ? width - len : 0;
 837                 CHECK(fill + len);
 838                 if (fill && !(flags&(FMINUS|FZERO))) {
 839                     FILL_(' ', fill);
 840                 }
 841                 if (sign || (flags&FSPACE)) {
 842                     buf[blen++] = sign > 0 ? '+' : sign < 0 ? '-' : ' ';
 843                 }
 844                 if (fill && (flags&(FMINUS|FZERO)) == FZERO) {
 845                     FILL_('0', fill);
 846                 }
 847                 len = RSTRING_LEN(val) + zero;
 848                 t = RSTRING_PTR(val);
 849                 if (len > prec) {
 850                     PUSH_(t, len - prec);
 851                 }
 852                 else {
 853                     buf[blen++] = '0';
 854                 }
 855                 if (prec > 0) {
 856                     buf[blen++] = '.';
 857                 }
 858                 if (zero) {
 859                     FILL_('0', zero);
 860                 }
 861                 else if (prec > len) {
 862                     FILL_('0', prec - len);
 863                     PUSH_(t, len);
 864                 }
 865                 else if (prec > 0) {
 866                     PUSH_(t + len - prec, prec);
 867                 }
 868                 if (fill && (flags&FMINUS)) {
 869                     FILL_(' ', fill);
 870                 }
 871                 RB_GC_GUARD(val);
 872                 break;
 873             }
 874           case 'g':
 875           case 'G':
 876           case 'e':
 877           case 'E':
 878             /* TODO: rational support */
 879           case 'a':
 880           case 'A':
 881           float_value:
 882             {
 883                 VALUE val = GETARG();
 884                 double fval;
 885
 886                 fval = RFLOAT_VALUE(rb_Float(val));
 887                 if (!isfinite(fval)) {
 888                     const char *expr;
 889                     int need;
 890                     int elen;
 891                     char sign = '\0';
 892
 893                     if (isnan(fval)) {
 894                         expr = "NaN";
 895                     }
 896                     else {
 897                         expr = "Inf";
 898                     }
 899                     need = (int)strlen(expr);
 900                     elen = need;
 901                     if (!isnan(fval) && fval < 0.0)
 902                         sign = '-';
 903                     else if (flags & (FPLUS|FSPACE))
 904                         sign = (flags & FPLUS) ? '+' : ' ';
 905                     if (sign)
 906                         ++need;
 907                     if ((flags & FWIDTH) && need < width)
 908                         need = width;
 909
 910                     FILL(' ', need);
 911                     if (flags & FMINUS) {
 912                         if (sign)
 913                             buf[blen - need--] = sign;
 914                         memcpy(&buf[blen - need], expr, elen);
 915                     }
 916                     else {
 917                         if (sign)
 918                             buf[blen - elen - 1] = sign;
 919                         memcpy(&buf[blen - elen], expr, elen);
 920                     }
 921                     break;
 922                 }
 923                 else {
 924                     int cr = ENC_CODERANGE(result);
 925                     char fbuf[2*BIT_DIGITS(SIZEOF_INT*CHAR_BIT)+10];
 926                     char *fmt = fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
 927                     rb_str_set_len(result, blen);
 928                     rb_str_catf(result, fmt, fval);
 929                     ENC_CODERANGE_SET(result, cr);
 930                     bsiz = rb_str_capacity(result);
 931                     RSTRING_GETMEM(result, buf, blen);
 932                 }
 933             }
 934             break;
 935         }
 936         flags = FNONE;
 937     }
 938
 939     update_coderange(FALSE);
 940   sprint_exit:
 941     rb_str_tmp_frozen_release(orig, fmt);
 942     /* XXX - We cannot validate the number of arguments if (digit)$ style used.
 943      */
 944     if (posarg >= 0 && nextarg < argc) {
 945         const char *mesg = "too many arguments for format string";
 946         if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg);
 947         if (RTEST(ruby_verbose)) rb_warn("%s", mesg);
 948     }
 949     rb_str_resize(result, blen);
 950
 951     return result;
 952 }
 953
 954 static char *
 955 fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
 956 {
 957     buf += size;
 958     *--buf = '\0';
 959     *--buf = c;
 960
 961     if (flags & FPREC) {
 962         buf = ruby_ultoa(prec, buf, 10, 0);
 963         *--buf = '.';
 964     }
 965
 966     if (flags & FWIDTH) {
 967         buf = ruby_ultoa(width, buf, 10, 0);
 968     }
 969
 970     if (flags & FSPACE) *--buf = ' ';
 971     if (flags & FZERO)  *--buf = '0';
 972     if (flags & FMINUS) *--buf = '-';
 973     if (flags & FPLUS)  *--buf = '+';
 974     if (flags & FSHARP) *--buf = '#';
 975     *--buf = '%';
 976     return buf;
 977 }
 978
 979 #undef FILE
 980 #define FILE rb_printf_buffer
 981 #define __sbuf rb_printf_sbuf
 982 #define __sFILE rb_printf_sfile
 983 #undef feof
 984 #undef ferror
 985 #undef clearerr
 986 #undef fileno
 987 #if SIZEOF_LONG < SIZEOF_LONG_LONG
 988 # if SIZEOF_LONG_LONG == SIZEOF_VOIDP
 989 /* actually this doesn't mean a pointer is strictly 64bit, but just
 990  * quad_t size */
 991 #   define _HAVE_LLP64_
 992 # endif
 993 # define _HAVE_SANE_QUAD_
 994 # define quad_t LONG_LONG
 995 # define u_quad_t unsigned LONG_LONG
 996 #endif
 997 #define FLOATING_POINT 1
 998 #define BSD__dtoa ruby_dtoa
 999 #define BSD__hdtoa ruby_hdtoa
1000 #ifdef RUBY_PRI_VALUE_MARK
1001 # define PRI_EXTRA_MARK RUBY_PRI_VALUE_MARK
1002 #endif
1003 #define lower_hexdigits (ruby_hexdigits+0)
1004 #define upper_hexdigits (ruby_hexdigits+16)
1005 #include "vsnprintf.c"
1006
1007 static char *
1008 ruby_ultoa(unsigned long val, char *endp, int base, int flags)
1009 {
1010     const char *xdigs = lower_hexdigits;
1011     int octzero = flags & FSHARP;
1012     return BSD__ultoa(val, endp, base, octzero, xdigs);
1013 }
1014
1015 static int ruby_do_vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
1016
1017 int
1018 ruby_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
1019 {
1020     if (str && (ssize_t)n < 1)
1021         return (EOF);
1022     return ruby_do_vsnprintf(str, n, fmt, ap);
1023 }
1024
1025 static int
1026 ruby_do_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
1027 {
1028     ssize_t ret;
1029     rb_printf_buffer f;
1030
1031     f._flags = __SWR | __SSTR;
1032     f._bf._base = f._p = (unsigned char *)str;
1033     f._bf._size = f._w = str ? (n - 1) : 0;
1034     f.vwrite = BSD__sfvwrite;
1035     f.vextra = 0;
1036     ret = BSD_vfprintf(&f, fmt, ap);
1037     if (str) *f._p = 0;
1038 #if SIZEOF_SIZE_T > SIZEOF_INT
1039     if (n > INT_MAX) return INT_MAX;
1040 #endif
1041     return (int)ret;
1042 }
1043
1044 int
1045 ruby_snprintf(char *str, size_t n, char const *fmt, ...)
1046 {
1047     int ret;
1048     va_list ap;
1049
1050     if (str && (ssize_t)n < 1)
1051         return (EOF);
1052
1053     va_start(ap, fmt);
1054     ret = ruby_do_vsnprintf(str, n, fmt, ap);
1055     va_end(ap);
1056     return ret;
1057 }
1058
1059 typedef struct {
1060     rb_printf_buffer base;
1061     volatile VALUE value;
1062 } rb_printf_buffer_extra;
1063
1064 static int
1065 ruby__sfvwrite(register rb_printf_buffer *fp, register struct __suio *uio)
1066 {
1067     struct __siov *iov;
1068     VALUE result = (VALUE)fp->_bf._base;
1069     char *buf = (char*)fp->_p;
1070     long len, n;
1071     long blen = buf - RSTRING_PTR(result), bsiz = fp->_w;
1072
1073     if (RBASIC(result)->klass) {
1074         rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1075     }
1076     if (uio->uio_resid == 0)
1077         return 0;
1078 #if SIZE_MAX > LONG_MAX
1079     if (uio->uio_resid >= LONG_MAX)
1080         rb_raise(rb_eRuntimeError, "too big string");
1081 #endif
1082     len = (long)uio->uio_resid;
1083     CHECK(len);
1084     buf += blen;
1085     fp->_w = bsiz;
1086     for (iov = uio->uio_iov; len > 0; ++iov) {
1087         MEMCPY(buf, iov->iov_base, char, n = iov->iov_len);
1088         buf += n;
1089         len -= n;
1090     }
1091     fp->_p = (unsigned char *)buf;
1092     rb_str_set_len(result, buf - RSTRING_PTR(result));
1093     return 0;
1094 }
1095
1096 static const char *
1097 ruby__sfvextra(rb_printf_buffer *fp, size_t valsize, void *valp, long *sz, int sign)
1098 {
1099     VALUE value, result = (VALUE)fp->_bf._base;
1100     rb_encoding *enc;
1101     char *cp;
1102
1103     if (valsize != sizeof(VALUE)) return 0;
1104     value = *(VALUE *)valp;
1105     if (RBASIC(result)->klass) {
1106         rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1107     }
1108     if (sign == '+') {
1109 # define LITERAL(str) (*sz = rb_strlen_lit(str), str)
1110         /* optimize special const cases */
1111         switch (value) {
1112 # define LITERAL_CASE(x) case Q##x: return LITERAL(#x)
1113           LITERAL_CASE(nil);
1114           LITERAL_CASE(true);
1115           LITERAL_CASE(false);
1116 # undef LITERAL_CASE
1117         }
1118 # undef LITERAL
1119         value = rb_inspect(value);
1120     }
1121     else if (SYMBOL_P(value)) {
1122         value = rb_sym2str(value);
1123         if (sign == ' ' && !rb_str_symname_p(value)) {
1124             value = rb_str_escape(value);
1125         }
1126     }
1127     else {
1128         value = rb_obj_as_string(value);
1129         if (sign == ' ') value = QUOTE(value);
1130     }
1131     enc = rb_enc_compatible(result, value);
1132     if (enc) {
1133         rb_enc_associate(result, enc);
1134     }
1135     else {
1136         enc = rb_enc_get(result);
1137         value = rb_str_conv_enc_opts(value, rb_enc_get(value), enc,
1138                                      ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE,
1139                                      Qnil);
1140         *(volatile VALUE *)valp = value;
1141     }
1142     StringValueCStr(value);
1143     RSTRING_GETMEM(value, cp, *sz);
1144     ((rb_printf_buffer_extra *)fp)->value = value;
1145     return cp;
1146 }
1147
1148 static void
1149 ruby_vsprintf0(VALUE result, char *p, const char *fmt, va_list ap)
1150 {
1151     rb_printf_buffer_extra buffer;
1152 #define f buffer.base
1153     VALUE klass = RBASIC(result)->klass;
1154     int coderange = ENC_CODERANGE(result);
1155     long scanned = 0;
1156
1157     if (coderange != ENC_CODERANGE_UNKNOWN) scanned = p - RSTRING_PTR(result);
1158
1159     f._flags = __SWR | __SSTR;
1160     f._bf._size = 0;
1161     f._w = rb_str_capacity(result);
1162     f._bf._base = (unsigned char *)result;
1163     f._p = (unsigned char *)p;
1164     RBASIC_CLEAR_CLASS(result);
1165     f.vwrite = ruby__sfvwrite;
1166     f.vextra = ruby__sfvextra;
1167     buffer.value = 0;
1168     BSD_vfprintf(&f, fmt, ap);
1169     RBASIC_SET_CLASS_RAW(result, klass);
1170     p = RSTRING_PTR(result);
1171     long blen = (char *)f._p - p;
1172     if (scanned < blen) {
1173         rb_str_coderange_scan_restartable(p + scanned, p + blen, rb_enc_get(result), &coderange);
1174         ENC_CODERANGE_SET(result, coderange);
1175     }
1176     rb_str_resize(result, blen);
1177 #undef f
1178 }
1179
1180 VALUE
1181 rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
1182 {
1183     const int initial_len = 120;
1184     VALUE result;
1185
1186     result = rb_str_buf_new(initial_len);
1187     if (enc) {
1188         if (rb_enc_mbminlen(enc) > 1) {
1189             /* the implementation deeply depends on plain char */
1190             rb_raise(rb_eArgError, "cannot construct wchar_t based encoding string: %s",
1191                      rb_enc_name(enc));
1192         }
1193         rb_enc_associate(result, enc);
1194     }
1195     ruby_vsprintf0(result, RSTRING_PTR(result), fmt, ap);
1196     return result;
1197 }
1198
1199 VALUE
1200 rb_enc_sprintf(rb_encoding *enc, const char *format, ...)
1201 {
1202     VALUE result;
1203     va_list ap;
1204
1205     va_start(ap, format);
1206     result = rb_enc_vsprintf(enc, format, ap);
1207     va_end(ap);
1208
1209     return result;
1210 }
1211
1212 VALUE
1213 rb_vsprintf(const char *fmt, va_list ap)
1214 {
1215     return rb_enc_vsprintf(NULL, fmt, ap);
1216 }
1217
1218 VALUE
1219 rb_sprintf(const char *format, ...)
1220 {
1221     VALUE result;
1222     va_list ap;
1223
1224     va_start(ap, format);
1225     result = rb_vsprintf(format, ap);
1226     va_end(ap);
1227
1228     return result;
1229 }
1230
1231 VALUE
1232 rb_str_vcatf(VALUE str, const char *fmt, va_list ap)
1233 {
1234     StringValue(str);
1235     rb_str_modify(str);
1236     ruby_vsprintf0(str, RSTRING_END(str), fmt, ap);
1237
1238     return str;
1239 }
1240
1241 VALUE
1242 rb_str_catf(VALUE str, const char *format, ...)
1243 {
1244     va_list ap;
1245
1246     va_start(ap, format);
1247     str = rb_str_vcatf(str, format, ap);
1248     va_end(ap);
1249
1250     return str;
1251 }