One Level Up Top Level

src/lj_strfmt.c - luajit-2.0-src

Global variables defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** String formatting.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. #include <stdio.h>

  8. ‌#define lj_strfmt_c
  9. ‌#define LUA_CORE

  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"

  18. /* -- Format parser ------------------------------------------------------- */

  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. };

  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. }

  90. /* -- Raw conversions ----------------------------------------------------- */

  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. }

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

  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

  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. }

  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. }

  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. }

  188. /* -- Unformatted conversions to buffer ----------------------------------- */

  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. }

  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

  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. }

  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. }

  242. /* -- Formatted conversions to buffer ------------------------------------- */

  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. }

  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. }

  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;

  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.   }

  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.   }

  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

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

  337.   lua_assert(need == (MSize)(p - ps));
  338.   setsbufP(sb, p);
  339.   return sb;
  340. }

  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. }

  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. }

  363. /* Max. sprintf buffer size needed. At least #string.format("%.99f", -1e308). */
  364. ‌#define STRFMT_FMTNUMBUF        512

  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. }

  420. /* -- Conversions to strings ---------------------------------------------- */

  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. }

  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. }

  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. }

  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

  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. }

  481. /* -- Internal string formatting ------------------------------------------ */

  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. */

  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. }

  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. }

One Level Up Top Level