source/libs/luajit/LuaJIT-src/src/lj_strfmt.c

   1 /*
   2 ** String formatting.
   3 ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #include <stdio.h>
   7
   8 #define lj_strfmt_c
   9 #define LUA_CORE
  10
  11 #include "lj_obj.h"
  12 #include "lj_buf.h"
  13 #include "lj_str.h"
  14 #include "lj_state.h"
  15 #include "lj_char.h"
  16 #include "lj_strfmt.h"
  17
  18 /* -- Format parser ------------------------------------------------------- */
  19
  20 static const uint8_t strfmt_map[('x'-'A')+1] = {
  21   STRFMT_A,0,0,0,STRFMT_E,0,STRFMT_G,0,0,0,0,0,0,
  22   0,0,0,0,0,0,0,0,0,0,STRFMT_X,0,0,
  23   0,0,0,0,0,0,
  24   STRFMT_A,0,STRFMT_C,STRFMT_D,STRFMT_E,STRFMT_F,STRFMT_G,0,STRFMT_I,0,0,0,0,
  25   0,STRFMT_O,STRFMT_P,STRFMT_Q,0,STRFMT_S,0,STRFMT_U,0,0,STRFMT_X
  26 };
  27
  28 SFormat LJ_FASTCALL lj_strfmt_parse(FormatState *fs)
  29 {
  30   const uint8_t *p = fs->p, *e = fs->e;
  31   fs->str = (const char *)p;
  32   for (; p < e; p++) {
  33     if (*p == '%') {  /* Escape char? */
  34       if (p[1] == '%') {  /* '%%'? */
  35         fs->p = ++p+1;
  36         goto retlit;
  37       } else {
  38         SFormat sf = 0;
  39         uint32_t c;
  40         if (p != (const uint8_t *)fs->str)
  41           break;
  42         for (p++; (uint32_t)*p - ' ' <= (uint32_t)('0' - ' '); p++) {
  43           /* Parse flags. */
  44           if (*p == '-') sf |= STRFMT_F_LEFT;
  45           else if (*p == '+') sf |= STRFMT_F_PLUS;
  46           else if (*p == '0') sf |= STRFMT_F_ZERO;
  47           else if (*p == ' ') sf |= STRFMT_F_SPACE;
  48           else if (*p == '#') sf |= STRFMT_F_ALT;
  49           else break;
  50         }
  51         if ((uint32_t)*p - '0' < 10) {  /* Parse width. */
  52           uint32_t width = (uint32_t)*p++ - '0';
  53           if ((uint32_t)*p - '0' < 10)
  54             width = (uint32_t)*p++ - '0' + width*10;
  55           sf |= (width << STRFMT_SH_WIDTH);
  56         }
  57         if (*p == '.') {  /* Parse precision. */
  58           uint32_t prec = 0;
  59           p++;
  60           if ((uint32_t)*p - '0' < 10) {
  61             prec = (uint32_t)*p++ - '0';
  62             if ((uint32_t)*p - '0' < 10)
  63               prec = (uint32_t)*p++ - '0' + prec*10;
  64           }
  65           sf |= ((prec+1) << STRFMT_SH_PREC);
  66         }
  67         /* Parse conversion. */
  68         c = (uint32_t)*p - 'A';
  69         if (LJ_LIKELY(c <= (uint32_t)('x' - 'A'))) {
  70           uint32_t sx = strfmt_map[c];
  71           if (sx) {
  72             fs->p = p+1;
  73             return (sf | sx | ((c & 0x20) ? 0 : STRFMT_F_UPPER));
  74           }
  75         }
  76         /* Return error location. */
  77         if (*p >= 32) p++;
  78         fs->len = (MSize)(p - (const uint8_t *)fs->str);
  79         fs->p = fs->e;
  80         return STRFMT_ERR;
  81       }
  82     }
  83   }
  84   fs->p = p;
  85 retlit:
  86   fs->len = (MSize)(p - (const uint8_t *)fs->str);
  87   return fs->len ? STRFMT_LIT : STRFMT_EOF;
  88 }
  89
  90 /* -- Raw conversions ----------------------------------------------------- */
  91
  92 /* Write number to bufer. */
  93 char * LJ_FASTCALL lj_strfmt_wnum(char *p, cTValue *o)
  94 {
  95   if (LJ_LIKELY((o->u32.hi << 1) < 0xffe00000)) {  /* Finite? */
  96 #if __BIONIC__
  97     if (tvismzero(o)) { *p++ = '-'; *p++ = '0'; return p; }
  98 #endif
  99     return p + lua_number2str(p, o->n);
 100   } else if (((o->u32.hi & 0x000fffff) | o->u32.lo) != 0) {
 101     *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
 102   } else if ((o->u32.hi & 0x80000000) == 0) {
 103     *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
 104   } else {
 105     *p++ = '-'; *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
 106   }
 107   return p;
 108 }
 109
 110 #define WINT_R(x, sh, sc) \
 111   { uint32_t d = (x*(((1<<sh)+sc-1)/sc))>>sh; x -= d*sc; *p++ = (char)('0'+d); }
 112
 113 /* Write integer to buffer. */
 114 char * LJ_FASTCALL lj_strfmt_wint(char *p, int32_t k)
 115 {
 116   uint32_t u = (uint32_t)k;
 117   if (k < 0) { u = (uint32_t)-k; *p++ = '-'; }
 118   if (u < 10000) {
 119     if (u < 10) goto dig1; if (u < 100) goto dig2; if (u < 1000) goto dig3;
 120   } else {
 121     uint32_t v = u / 10000; u -= v * 10000;
 122     if (v < 10000) {
 123       if (v < 10) goto dig5; if (v < 100) goto dig6; if (v < 1000) goto dig7;
 124     } else {
 125       uint32_t w = v / 10000; v -= w * 10000;
 126       if (w >= 10) WINT_R(w, 10, 10)
 127       *p++ = (char)('0'+w);
 128     }
 129     WINT_R(v, 23, 1000)
 130     dig7: WINT_R(v, 12, 100)
 131     dig6: WINT_R(v, 10, 10)
 132     dig5: *p++ = (char)('0'+v);
 133   }
 134   WINT_R(u, 23, 1000)
 135   dig3: WINT_R(u, 12, 100)
 136   dig2: WINT_R(u, 10, 10)
 137   dig1: *p++ = (char)('0'+u);
 138   return p;
 139 }
 140 #undef WINT_R
 141
 142 /* Write pointer to buffer. */
 143 char * LJ_FASTCALL lj_strfmt_wptr(char *p, const void *v)
 144 {
 145   ptrdiff_t x = (ptrdiff_t)v;
 146   MSize i, n = STRFMT_MAXBUF_PTR;
 147   if (x == 0) {
 148     *p++ = 'N'; *p++ = 'U'; *p++ = 'L'; *p++ = 'L';
 149     return p;
 150   }
 151 #if LJ_64
 152   /* Shorten output for 64 bit pointers. */
 153   n = 2+2*4+((x >> 32) ? 2+2*(lj_fls((uint32_t)(x >> 32))>>3) : 0);
 154 #endif
 155   p[0] = '0';
 156   p[1] = 'x';
 157   for (i = n-1; i >= 2; i--, x >>= 4)
 158     p[i] = "0123456789abcdef"[(x & 15)];
 159   return p+n;
 160 }
 161
 162 /* Write ULEB128 to buffer. */
 163 char * LJ_FASTCALL lj_strfmt_wuleb128(char *p, uint32_t v)
 164 {
 165   for (; v >= 0x80; v >>= 7)
 166     *p++ = (char)((v & 0x7f) | 0x80);
 167   *p++ = (char)v;
 168   return p;
 169 }
 170
 171 /* Return string or write number to buffer and return pointer to start. */
 172 const char *lj_strfmt_wstrnum(char *buf, cTValue *o, MSize *lenp)
 173 {
 174   if (tvisstr(o)) {
 175     *lenp = strV(o)->len;
 176     return strVdata(o);
 177   } else if (tvisint(o)) {
 178     *lenp = (MSize)(lj_strfmt_wint(buf, intV(o)) - buf);
 179     return buf;
 180   } else if (tvisnum(o)) {
 181     *lenp = (MSize)(lj_strfmt_wnum(buf, o) - buf);
 182     return buf;
 183   } else {
 184     return NULL;
 185   }
 186 }
 187
 188 /* -- Unformatted conversions to buffer ----------------------------------- */
 189
 190 /* Add integer to buffer. */
 191 SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k)
 192 {
 193   setsbufP(sb, lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT), k));
 194   return sb;
 195 }
 196
 197 #if LJ_HASJIT
 198 /* Add number to buffer. */
 199 SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o)
 200 {
 201   setsbufP(sb, lj_strfmt_wnum(lj_buf_more(sb, STRFMT_MAXBUF_NUM), o));
 202   return sb;
 203 }
 204 #endif
 205
 206 SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v)
 207 {
 208   setsbufP(sb, lj_strfmt_wptr(lj_buf_more(sb, STRFMT_MAXBUF_PTR), v));
 209   return sb;
 210 }
 211
 212 /* Add quoted string to buffer. */
 213 SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str)
 214 {
 215   const char *s = strdata(str);
 216   MSize len = str->len;
 217   lj_buf_putb(sb, '"');
 218   while (len--) {
 219     uint32_t c = (uint32_t)(uint8_t)*s++;
 220     char *p = lj_buf_more(sb, 4);
 221     if (c == '"' || c == '\\' || c == '\n') {
 222       *p++ = '\\';
 223     } else if (lj_char_iscntrl(c)) {  /* This can only be 0-31 or 127. */
 224       uint32_t d;
 225       *p++ = '\\';
 226       if (c >= 100 || lj_char_isdigit((uint8_t)*s)) {
 227         *p++ = (char)('0'+(c >= 100)); if (c >= 100) c -= 100;
 228         goto tens;
 229       } else if (c >= 10) {
 230       tens:
 231         d = (c * 205) >> 11; c -= d * 10; *p++ = (char)('0'+d);
 232       }
 233       c += '0';
 234     }
 235     *p++ = (char)c;
 236     setsbufP(sb, p);
 237   }
 238   lj_buf_putb(sb, '"');
 239   return sb;
 240 }
 241
 242 /* -- Formatted conversions to buffer ------------------------------------- */
 243
 244 /* Add formatted char to buffer. */
 245 SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat sf, int32_t c)
 246 {
 247   MSize width = STRFMT_WIDTH(sf);
 248   char *p = lj_buf_more(sb, width > 1 ? width : 1);
 249   if ((sf & STRFMT_F_LEFT)) *p++ = (char)c;
 250   while (width-- > 1) *p++ = ' ';
 251   if (!(sf & STRFMT_F_LEFT)) *p++ = (char)c;
 252   setsbufP(sb, p);
 253   return sb;
 254 }
 255
 256 /* Add formatted string to buffer. */
 257 SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat sf, GCstr *str)
 258 {
 259   MSize len = str->len <= STRFMT_PREC(sf) ? str->len : STRFMT_PREC(sf);
 260   MSize width = STRFMT_WIDTH(sf);
 261   char *p = lj_buf_more(sb, width > len ? width : len);
 262   if ((sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
 263   while (width-- > len) *p++ = ' ';
 264   if (!(sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
 265   setsbufP(sb, p);
 266   return sb;
 267 }
 268
 269 /* Add formatted signed/unsigned integer to buffer. */
 270 SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k)
 271 {
 272   char buf[STRFMT_MAXBUF_XINT], *q = buf + sizeof(buf), *p;
 273 #ifdef LUA_USE_ASSERT
 274   char *ps;
 275 #endif
 276   MSize prefix = 0, len, prec, pprec, width, need;
 277
 278   /* Figure out signed prefixes. */
 279   if (STRFMT_TYPE(sf) == STRFMT_INT) {
 280     if ((int64_t)k < 0) {
 281       k = (uint64_t)-(int64_t)k;
 282       prefix = 256 + '-';
 283     } else if ((sf & STRFMT_F_PLUS)) {
 284       prefix = 256 + '+';
 285     } else if ((sf & STRFMT_F_SPACE)) {
 286       prefix = 256 + ' ';
 287     }
 288   }
 289
 290   /* Convert number and store to fixed-size buffer in reverse order. */
 291   prec = STRFMT_PREC(sf);
 292   if ((int32_t)prec >= 0) sf &= ~STRFMT_F_ZERO;
 293   if (k == 0) {  /* Special-case zero argument. */
 294     if (prec != 0 ||
 295         (sf & (STRFMT_T_OCT|STRFMT_F_ALT)) == (STRFMT_T_OCT|STRFMT_F_ALT))
 296       *--q = '0';
 297   } else if (!(sf & (STRFMT_T_HEX|STRFMT_T_OCT))) {  /* Decimal. */
 298     uint32_t k2;
 299     while ((k >> 32)) { *--q = (char)('0' + k % 10); k /= 10; }
 300     k2 = (uint32_t)k;
 301     do { *--q = (char)('0' + k2 % 10); k2 /= 10; } while (k2);
 302   } else if ((sf & STRFMT_T_HEX)) {  /* Hex. */
 303     const char *hexdig = (sf & STRFMT_F_UPPER) ? "0123456789ABCDEF" :
 304                                                  "0123456789abcdef";
 305     do { *--q = hexdig[(k & 15)]; k >>= 4; } while (k);
 306     if ((sf & STRFMT_F_ALT)) prefix = 512 + ((sf & STRFMT_F_UPPER) ? 'X' : 'x');
 307   } else {  /* Octal. */
 308     do { *--q = (char)('0' + (uint32_t)(k & 7)); k >>= 3; } while (k);
 309     if ((sf & STRFMT_F_ALT)) *--q = '0';
 310   }
 311
 312   /* Calculate sizes. */
 313   len = (MSize)(buf + sizeof(buf) - q);
 314   if ((int32_t)len >= (int32_t)prec) prec = len;
 315   width = STRFMT_WIDTH(sf);
 316   pprec = prec + (prefix >> 8);
 317   need = width > pprec ? width : pprec;
 318   p = lj_buf_more(sb, need);
 319 #ifdef LUA_USE_ASSERT
 320   ps = p;
 321 #endif
 322
 323   /* Format number with leading/trailing whitespace and zeros. */
 324   if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == 0)
 325     while (width-- > pprec) *p++ = ' ';
 326   if (prefix) {
 327     if ((char)prefix >= 'X') *p++ = '0';
 328     *p++ = (char)prefix;
 329   }
 330   if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == STRFMT_F_ZERO)
 331     while (width-- > pprec) *p++ = '0';
 332   while (prec-- > len) *p++ = '0';
 333   while (q < buf + sizeof(buf)) *p++ = *q++;  /* Add number itself. */
 334   if ((sf & STRFMT_F_LEFT))
 335     while (width-- > pprec) *p++ = ' ';
 336
 337   lua_assert(need == (MSize)(p - ps));
 338   setsbufP(sb, p);
 339   return sb;
 340 }
 341
 342 /* Add number formatted as signed integer to buffer. */
 343 SBuf *lj_strfmt_putfnum_int(SBuf *sb, SFormat sf, lua_Number n)
 344 {
 345   int64_t k = (int64_t)n;
 346   if (checki32(k) && sf == STRFMT_INT)
 347     return lj_strfmt_putint(sb, (int32_t)k);  /* Shortcut for plain %d. */
 348   else
 349     return lj_strfmt_putfxint(sb, sf, (uint64_t)k);
 350 }
 351
 352 /* Add number formatted as unsigned integer to buffer. */
 353 SBuf *lj_strfmt_putfnum_uint(SBuf *sb, SFormat sf, lua_Number n)
 354 {
 355   int64_t k;
 356   if (n >= 9223372036854775808.0)
 357     k = (int64_t)(n - 18446744073709551616.0);
 358   else
 359     k = (int64_t)n;
 360   return lj_strfmt_putfxint(sb, sf, (uint64_t)k);
 361 }
 362
 363 /* Max. sprintf buffer size needed. At least #string.format("%.99f", -1e308). */
 364 #define STRFMT_FMTNUMBUF        512
 365
 366 /* Add formatted floating-point number to buffer. */
 367 SBuf *lj_strfmt_putfnum(SBuf *sb, SFormat sf, lua_Number n)
 368 {
 369   TValue tv;
 370   tv.n = n;
 371   if (LJ_UNLIKELY((tv.u32.hi << 1) >= 0xffe00000)) {
 372     /* Canonicalize output of non-finite values. */
 373     MSize width = STRFMT_WIDTH(sf), len = 3;
 374     int prefix = 0, ch = (sf & STRFMT_F_UPPER) ? 0x202020 : 0;
 375     char *p;
 376     if (((tv.u32.hi & 0x000fffff) | tv.u32.lo) != 0) {
 377       ch ^= ('n' << 16) | ('a' << 8) | 'n';
 378       if ((sf & STRFMT_F_SPACE)) prefix = ' ';
 379     } else {
 380       ch ^= ('i' << 16) | ('n' << 8) | 'f';
 381       if ((tv.u32.hi & 0x80000000)) prefix = '-';
 382       else if ((sf & STRFMT_F_PLUS)) prefix = '+';
 383       else if ((sf & STRFMT_F_SPACE)) prefix = ' ';
 384     }
 385     if (prefix) len = 4;
 386     p = lj_buf_more(sb, width > len ? width : len);
 387     if (!(sf & STRFMT_F_LEFT)) while (width-- > len) *p++ = ' ';
 388     if (prefix) *p++ = prefix;
 389     *p++ = (char)(ch >> 16); *p++ = (char)(ch >> 8); *p++ = (char)ch;
 390     if ((sf & STRFMT_F_LEFT)) while (width-- > len) *p++ = ' ';
 391     setsbufP(sb, p);
 392   } else {  /* Delegate to sprintf() for now. */
 393     uint8_t width = (uint8_t)STRFMT_WIDTH(sf), prec = (uint8_t)STRFMT_PREC(sf);
 394     char fmt[1+5+2+3+1+1], *p = fmt;
 395     *p++ = '%';
 396     if ((sf & STRFMT_F_LEFT)) *p++ = '-';
 397     if ((sf & STRFMT_F_PLUS)) *p++ = '+';
 398     if ((sf & STRFMT_F_ZERO)) *p++ = '0';
 399     if ((sf & STRFMT_F_SPACE)) *p++ = ' ';
 400     if ((sf & STRFMT_F_ALT)) *p++ = '#';
 401     if (width) {
 402       uint8_t x = width / 10, y = width % 10;
 403       if (x) *p++ = '0' + x;
 404       *p++ = '0' + y;
 405     }
 406     if (prec != 255) {
 407       uint8_t x = prec / 10, y = prec % 10;
 408       *p++ = '.';
 409       if (x) *p++ = '0' + x;
 410       *p++ = '0' + y;
 411     }
 412     *p++ = (0x67666561 >> (STRFMT_FP(sf)<<3)) ^ ((sf & STRFMT_F_UPPER)?0x20:0);
 413     *p = '\0';
 414     p = lj_buf_more(sb, STRFMT_FMTNUMBUF);
 415     setsbufP(sb, p + sprintf(p, fmt, n));
 416   }
 417   return sb;
 418 }
 419
 420 /* -- Conversions to strings ---------------------------------------------- */
 421
 422 /* Convert integer to string. */
 423 GCstr * LJ_FASTCALL lj_strfmt_int(lua_State *L, int32_t k)
 424 {
 425   char buf[STRFMT_MAXBUF_INT];
 426   MSize len = (MSize)(lj_strfmt_wint(buf, k) - buf);
 427   return lj_str_new(L, buf, len);
 428 }
 429
 430 /* Convert number to string. */
 431 GCstr * LJ_FASTCALL lj_strfmt_num(lua_State *L, cTValue *o)
 432 {
 433   char buf[STRFMT_MAXBUF_NUM];
 434   MSize len = (MSize)(lj_strfmt_wnum(buf, o) - buf);
 435   return lj_str_new(L, buf, len);
 436 }
 437
 438 /* Convert integer or number to string. */
 439 GCstr * LJ_FASTCALL lj_strfmt_number(lua_State *L, cTValue *o)
 440 {
 441   return tvisint(o) ? lj_strfmt_int(L, intV(o)) : lj_strfmt_num(L, o);
 442 }
 443
 444 #if LJ_HASJIT
 445 /* Convert char value to string. */
 446 GCstr * LJ_FASTCALL lj_strfmt_char(lua_State *L, int c)
 447 {
 448   char buf[1];
 449   buf[0] = c;
 450   return lj_str_new(L, buf, 1);
 451 }
 452 #endif
 453
 454 /* Raw conversion of object to string. */
 455 GCstr * LJ_FASTCALL lj_strfmt_obj(lua_State *L, cTValue *o)
 456 {
 457   if (tvisstr(o)) {
 458     return strV(o);
 459   } else if (tvisnumber(o)) {
 460     return lj_strfmt_number(L, o);
 461   } else if (tvisnil(o)) {
 462     return lj_str_newlit(L, "nil");
 463   } else if (tvisfalse(o)) {
 464     return lj_str_newlit(L, "false");
 465   } else if (tvistrue(o)) {
 466     return lj_str_newlit(L, "true");
 467   } else {
 468     char buf[8+2+2+16], *p = buf;
 469     p = lj_buf_wmem(p, lj_typename(o), (MSize)strlen(lj_typename(o)));
 470     *p++ = ':'; *p++ = ' ';
 471     if (tvisfunc(o) && isffunc(funcV(o))) {
 472       p = lj_buf_wmem(p, "builtin#", 8);
 473       p = lj_strfmt_wint(p, funcV(o)->c.ffid);
 474     } else {
 475       p = lj_strfmt_wptr(p, lj_obj_ptr(o));
 476     }
 477     return lj_str_new(L, buf, (size_t)(p - buf));
 478   }
 479 }
 480
 481 /* -- Internal string formatting ------------------------------------------ */
 482
 483 /*
 484 ** These functions are only used for lua_pushfstring(), lua_pushvfstring()
 485 ** and for internal string formatting (e.g. error messages). Caveat: unlike
 486 ** string.format(), only a limited subset of formats and flags are supported!
 487 **
 488 ** LuaJIT has support for a couple more formats than Lua 5.1/5.2:
 489 ** - %d %u %o %x with full formatting, 32 bit integers only.
 490 ** - %f and other FP formats are really %.14g.
 491 ** - %s %c %p without formatting.
 492 */
 493
 494 /* Push formatted message as a string object to Lua stack. va_list variant. */
 495 const char *lj_strfmt_pushvf(lua_State *L, const char *fmt, va_list argp)
 496 {
 497   SBuf *sb = lj_buf_tmp_(L);
 498   FormatState fs;
 499   SFormat sf;
 500   GCstr *str;
 501   lj_strfmt_init(&fs, fmt, (MSize)strlen(fmt));
 502   while ((sf = lj_strfmt_parse(&fs)) != STRFMT_EOF) {
 503     switch (STRFMT_TYPE(sf)) {
 504     case STRFMT_LIT:
 505       lj_buf_putmem(sb, fs.str, fs.len);
 506       break;
 507     case STRFMT_INT:
 508       lj_strfmt_putfxint(sb, sf, va_arg(argp, int32_t));
 509       break;
 510     case STRFMT_UINT:
 511       lj_strfmt_putfxint(sb, sf, va_arg(argp, uint32_t));
 512       break;
 513     case STRFMT_NUM: {
 514       TValue tv;
 515       tv.n = va_arg(argp, lua_Number);
 516       setsbufP(sb, lj_strfmt_wnum(lj_buf_more(sb, STRFMT_MAXBUF_NUM), &tv));
 517       break;
 518       }
 519     case STRFMT_STR: {
 520       const char *s = va_arg(argp, char *);
 521       if (s == NULL) s = "(null)";
 522       lj_buf_putmem(sb, s, (MSize)strlen(s));
 523       break;
 524       }
 525     case STRFMT_CHAR:
 526       lj_buf_putb(sb, va_arg(argp, int));
 527       break;
 528     case STRFMT_PTR:
 529       lj_strfmt_putptr(sb, va_arg(argp, void *));
 530       break;
 531     case STRFMT_ERR:
 532     default:
 533       lj_buf_putb(sb, '?');
 534       lua_assert(0);
 535       break;
 536     }
 537   }
 538   str = lj_buf_str(L, sb);
 539   setstrV(L, L->top, str);
 540   incr_top(L);
 541   return strdata(str);
 542 }
 543
 544 /* Push formatted message as a string object to Lua stack. Vararg variant. */
 545 const char *lj_strfmt_pushf(lua_State *L, const char *fmt, ...)
 546 {
 547   const char *msg;
 548   va_list argp;
 549   va_start(argp, fmt);
 550   msg = lj_strfmt_pushvf(L, fmt, argp);
 551   va_end(argp);
 552   return msg;
 553 }
 554