lolengine
/
lol
zrcadlo https://github.com/lolengine/lol
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
1781 Revize
5 Větve
412 MiB
 
 
 
Strom: afefed080b
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „afefed080b“
${ noResults }
lol/src/lua/lstrlib.c

976 řádky
26 KiB
Surový Blame Historie 

  1. /*

  2. ** $Id: lstrlib.c,v 1.176 2012/05/23 15:37:09 roberto Exp $

  3. ** Standard library for string operations and pattern-matching

  4. ** See Copyright Notice in lua.h

  5. */

  6. 

  7. #if defined HAVE_CONFIG_H // LOL BEGIN

  8. #   include "config.h"

  9. #endif // LOL END

  10. 

  11. #include <ctype.h>

  12. #include <stddef.h>

  13. #include <stdio.h>

  14. #include <stdlib.h>

  15. #include <string.h>

  16. 

  17. #define lstrlib_c

  18. #define LUA_LIB

  19. 

  20. #include "lua.h"

  21. 

  22. #include "lauxlib.h"

  23. #include "lualib.h"

  24. 

  25. 

  26. /*

  27. ** maximum number of captures that a pattern can do during

  28. ** pattern-matching. This limit is arbitrary.

  29. */

  30. #if !defined(LUA_MAXCAPTURES)

  31. #define LUA_MAXCAPTURES		32

  32. #endif

  33. 

  34. 

  35. /* macro to `unsign' a character */

  36. #define uchar(c)	((unsigned char)(c))

  37. 

  38. 

  39. 

  40. static int str_len (lua_State *L) {

  41.   size_t l;

  42.   luaL_checklstring(L, 1, &l);

  43.   lua_pushinteger(L, (lua_Integer)l);

  44.   return 1;

  45. }

  46. 

  47. 

  48. /* translate a relative string position: negative means back from end */

  49. static size_t posrelat (ptrdiff_t pos, size_t len) {

  50.   if (pos >= 0) return (size_t)pos;

  51.   else if (0u - (size_t)pos > len) return 0;

  52.   else return len - ((size_t)-pos) + 1;

  53. }

  54. 

  55. 

  56. static int str_sub (lua_State *L) {

  57.   size_t l;

  58.   const char *s = luaL_checklstring(L, 1, &l);

  59.   size_t start = posrelat(luaL_checkinteger(L, 2), l);

  60.   size_t end = posrelat(luaL_optinteger(L, 3, -1), l);

  61.   if (start < 1) start = 1;

  62.   if (end > l) end = l;

  63.   if (start <= end)

  64.     lua_pushlstring(L, s + start - 1, end - start + 1);

  65.   else lua_pushliteral(L, "");

  66.   return 1;

  67. }

  68. 

  69. 

  70. static int str_reverse (lua_State *L) {

  71.   size_t l, i;

  72.   luaL_Buffer b;

  73.   const char *s = luaL_checklstring(L, 1, &l);

  74.   char *p = luaL_buffinitsize(L, &b, l);

  75.   for (i = 0; i < l; i++)

  76.     p[i] = s[l - i - 1];

  77.   luaL_pushresultsize(&b, l);

  78.   return 1;

  79. }

  80. 

  81. 

  82. static int str_lower (lua_State *L) {

  83.   size_t l;

  84.   size_t i;

  85.   luaL_Buffer b;

  86.   const char *s = luaL_checklstring(L, 1, &l);

  87.   char *p = luaL_buffinitsize(L, &b, l);

  88.   for (i=0; i<l; i++)

  89.     p[i] = tolower(uchar(s[i]));

  90.   luaL_pushresultsize(&b, l);

  91.   return 1;

  92. }

  93. 

  94. 

  95. static int str_upper (lua_State *L) {

  96.   size_t l;

  97.   size_t i;

  98.   luaL_Buffer b;

  99.   const char *s = luaL_checklstring(L, 1, &l);

  100.   char *p = luaL_buffinitsize(L, &b, l);

  101.   for (i=0; i<l; i++)

  102.     p[i] = toupper(uchar(s[i]));

  103.   luaL_pushresultsize(&b, l);

  104.   return 1;

  105. }

  106. 

  107. 

  108. /* reasonable limit to avoid arithmetic overflow */

  109. #define MAXSIZE		((~(size_t)0) >> 1)

  110. 

  111. static int str_rep (lua_State *L) {

  112.   size_t l, lsep;

  113.   const char *s = luaL_checklstring(L, 1, &l);

  114.   int n = luaL_checkint(L, 2);

  115.   const char *sep = luaL_optlstring(L, 3, "", &lsep);

  116.   if (n <= 0) lua_pushliteral(L, "");

  117.   else if (l + lsep < l || l + lsep >= MAXSIZE / n)  /* may overflow? */

  118.     return luaL_error(L, "resulting string too large");

  119.   else {

  120.     size_t totallen = n * l + (n - 1) * lsep;

  121.     luaL_Buffer b;

  122.     char *p = luaL_buffinitsize(L, &b, totallen);

  123.     while (n-- > 1) {  /* first n-1 copies (followed by separator) */

  124.       memcpy(p, s, l * sizeof(char)); p += l;

  125.       if (lsep > 0) {  /* avoid empty 'memcpy' (may be expensive) */

  126.         memcpy(p, sep, lsep * sizeof(char)); p += lsep;

  127.       }

  128.     }

  129.     memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */

  130.     luaL_pushresultsize(&b, totallen);

  131.   }

  132.   return 1;

  133. }

  134. 

  135. 

  136. static int str_byte (lua_State *L) {

  137.   size_t l;

  138.   const char *s = luaL_checklstring(L, 1, &l);

  139.   size_t posi = posrelat(luaL_optinteger(L, 2, 1), l);

  140.   size_t pose = posrelat(luaL_optinteger(L, 3, posi), l);

  141.   int n, i;

  142.   if (posi < 1) posi = 1;

  143.   if (pose > l) pose = l;

  144.   if (posi > pose) return 0;  /* empty interval; return no values */

  145.   n = (int)(pose -  posi + 1);

  146.   if (posi + n <= pose)  /* (size_t -> int) overflow? */

  147.     return luaL_error(L, "string slice too long");

  148.   luaL_checkstack(L, n, "string slice too long");

  149.   for (i=0; i<n; i++)

  150.     lua_pushinteger(L, uchar(s[posi+i-1]));

  151.   return n;

  152. }

  153. 

  154. 

  155. static int str_char (lua_State *L) {

  156.   int n = lua_gettop(L);  /* number of arguments */

  157.   int i;

  158.   luaL_Buffer b;

  159.   char *p = luaL_buffinitsize(L, &b, n);

  160.   for (i=1; i<=n; i++) {

  161.     int c = luaL_checkint(L, i);

  162.     luaL_argcheck(L, uchar(c) == c, i, "value out of range");

  163.     p[i - 1] = uchar(c);

  164.   }

  165.   luaL_pushresultsize(&b, n);

  166.   return 1;

  167. }

  168. 

  169. 

  170. static int writer (lua_State *L, const void* b, size_t size, void* B) {

  171.   (void)L;

  172.   luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);

  173.   return 0;

  174. }

  175. 

  176. 

  177. static int str_dump (lua_State *L) {

  178.   luaL_Buffer b;

  179.   luaL_checktype(L, 1, LUA_TFUNCTION);

  180.   lua_settop(L, 1);

  181.   luaL_buffinit(L,&b);

  182.   if (lua_dump(L, writer, &b) != 0)

  183.     return luaL_error(L, "unable to dump given function");

  184.   luaL_pushresult(&b);

  185.   return 1;

  186. }

  187. 

  188. 

  189. 

  190. /*

  191. ** {======================================================

  192. ** PATTERN MATCHING

  193. ** =======================================================

  194. */

  195. 

  196. 

  197. #define CAP_UNFINISHED	(-1)

  198. #define CAP_POSITION	(-2)

  199. 

  200. typedef struct MatchState {

  201.   const char *src_init;  /* init of source string */

  202.   const char *src_end;  /* end ('\0') of source string */

  203.   const char *p_end;  /* end ('\0') of pattern */

  204.   lua_State *L;

  205.   int level;  /* total number of captures (finished or unfinished) */

  206.   struct {

  207.     const char *init;

  208.     ptrdiff_t len;

  209.   } capture[LUA_MAXCAPTURES];

  210. } MatchState;

  211. 

  212. 

  213. #define L_ESC		'%'

  214. #define SPECIALS	"^$*+?.([%-"

  215. 

  216. 

  217. static int check_capture (MatchState *ms, int l) {

  218.   l -= '1';

  219.   if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)

  220.     return luaL_error(ms->L, "invalid capture index %%%d", l + 1);

  221.   return l;

  222. }

  223. 

  224. 

  225. static int capture_to_close (MatchState *ms) {

  226.   int level = ms->level;

  227.   for (level--; level>=0; level--)

  228.     if (ms->capture[level].len == CAP_UNFINISHED) return level;

  229.   return luaL_error(ms->L, "invalid pattern capture");

  230. }

  231. 

  232. 

  233. static const char *classend (MatchState *ms, const char *p) {

  234.   switch (*p++) {

  235.     case L_ESC: {

  236.       if (p == ms->p_end)

  237.         luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");

  238.       return p+1;

  239.     }

  240.     case '[': {

  241.       if (*p == '^') p++;

  242.       do {  /* look for a `]' */

  243.         if (p == ms->p_end)

  244.           luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");

  245.         if (*(p++) == L_ESC && p < ms->p_end)

  246.           p++;  /* skip escapes (e.g. `%]') */

  247.       } while (*p != ']');

  248.       return p+1;

  249.     }

  250.     default: {

  251.       return p;

  252.     }

  253.   }

  254. }

  255. 

  256. 

  257. static int match_class (int c, int cl) {

  258.   int res;

  259.   switch (tolower(cl)) {

  260.     case 'a' : res = isalpha(c); break;

  261.     case 'c' : res = iscntrl(c); break;

  262.     case 'd' : res = isdigit(c); break;

  263.     case 'g' : res = isgraph(c); break;

  264.     case 'l' : res = islower(c); break;

  265.     case 'p' : res = ispunct(c); break;

  266.     case 's' : res = isspace(c); break;

  267.     case 'u' : res = isupper(c); break;

  268.     case 'w' : res = isalnum(c); break;

  269.     case 'x' : res = isxdigit(c); break;

  270.     case 'z' : res = (c == 0); break;  /* deprecated option */

  271.     default: return (cl == c);

  272.   }

  273.   return (islower(cl) ? res : !res);

  274. }

  275. 

  276. 

  277. static int matchbracketclass (int c, const char *p, const char *ec) {

  278.   int sig = 1;

  279.   if (*(p+1) == '^') {

  280.     sig = 0;

  281.     p++;  /* skip the `^' */

  282.   }

  283.   while (++p < ec) {

  284.     if (*p == L_ESC) {

  285.       p++;

  286.       if (match_class(c, uchar(*p)))

  287.         return sig;

  288.     }

  289.     else if ((*(p+1) == '-') && (p+2 < ec)) {

  290.       p+=2;

  291.       if (uchar(*(p-2)) <= c && c <= uchar(*p))

  292.         return sig;

  293.     }

  294.     else if (uchar(*p) == c) return sig;

  295.   }

  296.   return !sig;

  297. }

  298. 

  299. 

  300. static int singlematch (int c, const char *p, const char *ep) {

  301.   switch (*p) {

  302.     case '.': return 1;  /* matches any char */

  303.     case L_ESC: return match_class(c, uchar(*(p+1)));

  304.     case '[': return matchbracketclass(c, p, ep-1);

  305.     default:  return (uchar(*p) == c);

  306.   }

  307. }

  308. 

  309. 

  310. static const char *match (MatchState *ms, const char *s, const char *p);

  311. 

  312. 

  313. static const char *matchbalance (MatchState *ms, const char *s,

  314.                                    const char *p) {

  315.   if (p >= ms->p_end - 1)

  316.     luaL_error(ms->L, "malformed pattern "

  317.                       "(missing arguments to " LUA_QL("%%b") ")");

  318.   if (*s != *p) return NULL;

  319.   else {

  320.     int b = *p;

  321.     int e = *(p+1);

  322.     int cont = 1;

  323.     while (++s < ms->src_end) {

  324.       if (*s == e) {

  325.         if (--cont == 0) return s+1;

  326.       }

  327.       else if (*s == b) cont++;

  328.     }

  329.   }

  330.   return NULL;  /* string ends out of balance */

  331. }

  332. 

  333. 

  334. static const char *max_expand (MatchState *ms, const char *s,

  335.                                  const char *p, const char *ep) {

  336.   ptrdiff_t i = 0;  /* counts maximum expand for item */

  337.   while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))

  338.     i++;

  339.   /* keeps trying to match with the maximum repetitions */

  340.   while (i>=0) {

  341.     const char *res = match(ms, (s+i), ep+1);

  342.     if (res) return res;

  343.     i--;  /* else didn't match; reduce 1 repetition to try again */

  344.   }

  345.   return NULL;

  346. }

  347. 

  348. 

  349. static const char *min_expand (MatchState *ms, const char *s,

  350.                                  const char *p, const char *ep) {

  351.   for (;;) {

  352.     const char *res = match(ms, s, ep+1);

  353.     if (res != NULL)

  354.       return res;

  355.     else if (s<ms->src_end && singlematch(uchar(*s), p, ep))

  356.       s++;  /* try with one more repetition */

  357.     else return NULL;

  358.   }

  359. }

  360. 

  361. 

  362. static const char *start_capture (MatchState *ms, const char *s,

  363.                                     const char *p, int what) {

  364.   const char *res;

  365.   int level = ms->level;

  366.   if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");

  367.   ms->capture[level].init = s;

  368.   ms->capture[level].len = what;

  369.   ms->level = level+1;

  370.   if ((res=match(ms, s, p)) == NULL)  /* match failed? */

  371.     ms->level--;  /* undo capture */

  372.   return res;

  373. }

  374. 

  375. 

  376. static const char *end_capture (MatchState *ms, const char *s,

  377.                                   const char *p) {

  378.   int l = capture_to_close(ms);

  379.   const char *res;

  380.   ms->capture[l].len = s - ms->capture[l].init;  /* close capture */

  381.   if ((res = match(ms, s, p)) == NULL)  /* match failed? */

  382.     ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */

  383.   return res;

  384. }

  385. 

  386. 

  387. static const char *match_capture (MatchState *ms, const char *s, int l) {

  388.   size_t len;

  389.   l = check_capture(ms, l);

  390.   len = ms->capture[l].len;

  391.   if ((size_t)(ms->src_end-s) >= len &&

  392.       memcmp(ms->capture[l].init, s, len) == 0)

  393.     return s+len;

  394.   else return NULL;

  395. }

  396. 

  397. 

  398. static const char *match (MatchState *ms, const char *s, const char *p) {

  399.   init: /* using goto's to optimize tail recursion */

  400.   if (p == ms->p_end)  /* end of pattern? */

  401.     return s;  /* match succeeded */

  402.   switch (*p) {

  403.     case '(': {  /* start capture */

  404.       if (*(p+1) == ')')  /* position capture? */

  405.         return start_capture(ms, s, p+2, CAP_POSITION);

  406.       else

  407.         return start_capture(ms, s, p+1, CAP_UNFINISHED);

  408.     }

  409.     case ')': {  /* end capture */

  410.       return end_capture(ms, s, p+1);

  411.     }

  412.     case '$': {

  413.       if ((p+1) == ms->p_end)  /* is the `$' the last char in pattern? */

  414.         return (s == ms->src_end) ? s : NULL;  /* check end of string */

  415.       else goto dflt;

  416.     }

  417.     case L_ESC: {  /* escaped sequences not in the format class[*+?-]? */

  418.       switch (*(p+1)) {

  419.         case 'b': {  /* balanced string? */

  420.           s = matchbalance(ms, s, p+2);

  421.           if (s == NULL) return NULL;

  422.           p+=4; goto init;  /* else return match(ms, s, p+4); */

  423.         }

  424.         case 'f': {  /* frontier? */

  425.           const char *ep; char previous;

  426.           p += 2;

  427.           if (*p != '[')

  428.             luaL_error(ms->L, "missing " LUA_QL("[") " after "

  429.                                LUA_QL("%%f") " in pattern");

  430.           ep = classend(ms, p);  /* points to what is next */

  431.           previous = (s == ms->src_init) ? '\0' : *(s-1);

  432.           if (matchbracketclass(uchar(previous), p, ep-1) ||

  433.              !matchbracketclass(uchar(*s), p, ep-1)) return NULL;

  434.           p=ep; goto init;  /* else return match(ms, s, ep); */

  435.         }

  436.         case '0': case '1': case '2': case '3':

  437.         case '4': case '5': case '6': case '7':

  438.         case '8': case '9': {  /* capture results (%0-%9)? */

  439.           s = match_capture(ms, s, uchar(*(p+1)));

  440.           if (s == NULL) return NULL;

  441.           p+=2; goto init;  /* else return match(ms, s, p+2) */

  442.         }

  443.         default: goto dflt;

  444.       }

  445.     }

  446.     default: dflt: {  /* pattern class plus optional suffix */

  447.       const char *ep = classend(ms, p);  /* points to what is next */

  448.       int m = s < ms->src_end && singlematch(uchar(*s), p, ep);

  449.       switch (*ep) {

  450.         case '?': {  /* optional */

  451.           const char *res;

  452.           if (m && ((res=match(ms, s+1, ep+1)) != NULL))

  453.             return res;

  454.           p=ep+1; goto init;  /* else return match(ms, s, ep+1); */

  455.         }

  456.         case '*': {  /* 0 or more repetitions */

  457.           return max_expand(ms, s, p, ep);

  458.         }

  459.         case '+': {  /* 1 or more repetitions */

  460.           return (m ? max_expand(ms, s+1, p, ep) : NULL);

  461.         }

  462.         case '-': {  /* 0 or more repetitions (minimum) */

  463.           return min_expand(ms, s, p, ep);

  464.         }

  465.         default: {

  466.           if (!m) return NULL;

  467.           s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */

  468.         }

  469.       }

  470.     }

  471.   }

  472. }

  473. 

  474. 

  475. 

  476. static const char *lmemfind (const char *s1, size_t l1,

  477.                                const char *s2, size_t l2) {

  478.   if (l2 == 0) return s1;  /* empty strings are everywhere */

  479.   else if (l2 > l1) return NULL;  /* avoids a negative `l1' */

  480.   else {

  481.     const char *init;  /* to search for a `*s2' inside `s1' */

  482.     l2--;  /* 1st char will be checked by `memchr' */

  483.     l1 = l1-l2;  /* `s2' cannot be found after that */

  484.     while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {

  485.       init++;   /* 1st char is already checked */

  486.       if (memcmp(init, s2+1, l2) == 0)

  487.         return init-1;

  488.       else {  /* correct `l1' and `s1' to try again */

  489.         l1 -= init-s1;

  490.         s1 = init;

  491.       }

  492.     }

  493.     return NULL;  /* not found */

  494.   }

  495. }

  496. 

  497. 

  498. static void push_onecapture (MatchState *ms, int i, const char *s,

  499.                                                     const char *e) {

  500.   if (i >= ms->level) {

  501.     if (i == 0)  /* ms->level == 0, too */

  502.       lua_pushlstring(ms->L, s, e - s);  /* add whole match */

  503.     else

  504.       luaL_error(ms->L, "invalid capture index");

  505.   }

  506.   else {

  507.     ptrdiff_t l = ms->capture[i].len;

  508.     if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");

  509.     if (l == CAP_POSITION)

  510.       lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);

  511.     else

  512.       lua_pushlstring(ms->L, ms->capture[i].init, l);

  513.   }

  514. }

  515. 

  516. 

  517. static int push_captures (MatchState *ms, const char *s, const char *e) {

  518.   int i;

  519.   int nlevels = (ms->level == 0 && s) ? 1 : ms->level;

  520.   luaL_checkstack(ms->L, nlevels, "too many captures");

  521.   for (i = 0; i < nlevels; i++)

  522.     push_onecapture(ms, i, s, e);

  523.   return nlevels;  /* number of strings pushed */

  524. }

  525. 

  526. 

  527. /* check whether pattern has no special characters */

  528. static int nospecials (const char *p, size_t l) {

  529.   size_t upto = 0;

  530.   do {

  531.     if (strpbrk(p + upto, SPECIALS))

  532.       return 0;  /* pattern has a special character */

  533.     upto += strlen(p + upto) + 1;  /* may have more after \0 */

  534.   } while (upto <= l);

  535.   return 1;  /* no special chars found */

  536. }

  537. 

  538. 

  539. static int str_find_aux (lua_State *L, int find) {

  540.   size_t ls, lp;

  541.   const char *s = luaL_checklstring(L, 1, &ls);

  542.   const char *p = luaL_checklstring(L, 2, &lp);

  543.   size_t init = posrelat(luaL_optinteger(L, 3, 1), ls);

  544.   if (init < 1) init = 1;

  545.   else if (init > ls + 1) {  /* start after string's end? */

  546.     lua_pushnil(L);  /* cannot find anything */

  547.     return 1;

  548.   }

  549.   /* explicit request or no special characters? */

  550.   if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {

  551.     /* do a plain search */

  552.     const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp);

  553.     if (s2) {

  554.       lua_pushinteger(L, s2 - s + 1);

  555.       lua_pushinteger(L, s2 - s + lp);

  556.       return 2;

  557.     }

  558.   }

  559.   else {

  560.     MatchState ms;

  561.     const char *s1 = s + init - 1;

  562.     int anchor = (*p == '^');

  563.     if (anchor) {

  564.       p++; lp--;  /* skip anchor character */

  565.     }

  566.     ms.L = L;

  567.     ms.src_init = s;

  568.     ms.src_end = s + ls;

  569.     ms.p_end = p + lp;

  570.     do {

  571.       const char *res;

  572.       ms.level = 0;

  573.       if ((res=match(&ms, s1, p)) != NULL) {

  574.         if (find) {

  575.           lua_pushinteger(L, s1 - s + 1);  /* start */

  576.           lua_pushinteger(L, res - s);   /* end */

  577.           return push_captures(&ms, NULL, 0) + 2;

  578.         }

  579.         else

  580.           return push_captures(&ms, s1, res);

  581.       }

  582.     } while (s1++ < ms.src_end && !anchor);

  583.   }

  584.   lua_pushnil(L);  /* not found */

  585.   return 1;

  586. }

  587. 

  588. 

  589. static int str_find (lua_State *L) {

  590.   return str_find_aux(L, 1);

  591. }

  592. 

  593. 

  594. static int str_match (lua_State *L) {

  595.   return str_find_aux(L, 0);

  596. }

  597. 

  598. 

  599. static int gmatch_aux (lua_State *L) {

  600.   MatchState ms;

  601.   size_t ls, lp;

  602.   const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);

  603.   const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp);

  604.   const char *src;

  605.   ms.L = L;

  606.   ms.src_init = s;

  607.   ms.src_end = s+ls;

  608.   ms.p_end = p + lp;

  609.   for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));

  610.        src <= ms.src_end;

  611.        src++) {

  612.     const char *e;

  613.     ms.level = 0;

  614.     if ((e = match(&ms, src, p)) != NULL) {

  615.       lua_Integer newstart = e-s;

  616.       if (e == src) newstart++;  /* empty match? go at least one position */

  617.       lua_pushinteger(L, newstart);

  618.       lua_replace(L, lua_upvalueindex(3));

  619.       return push_captures(&ms, src, e);

  620.     }

  621.   }

  622.   return 0;  /* not found */

  623. }

  624. 

  625. 

  626. static int gmatch (lua_State *L) {

  627.   luaL_checkstring(L, 1);

  628.   luaL_checkstring(L, 2);

  629.   lua_settop(L, 2);

  630.   lua_pushinteger(L, 0);

  631.   lua_pushcclosure(L, gmatch_aux, 3);

  632.   return 1;

  633. }

  634. 

  635. 

  636. static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,

  637.                                                    const char *e) {

  638.   size_t l, i;

  639.   const char *news = lua_tolstring(ms->L, 3, &l);

  640.   for (i = 0; i < l; i++) {

  641.     if (news[i] != L_ESC)

  642.       luaL_addchar(b, news[i]);

  643.     else {

  644.       i++;  /* skip ESC */

  645.       if (!isdigit(uchar(news[i]))) {

  646.         if (news[i] != L_ESC)

  647.           luaL_error(ms->L, "invalid use of " LUA_QL("%c")

  648.                            " in replacement string", L_ESC);

  649.         luaL_addchar(b, news[i]);

  650.       }

  651.       else if (news[i] == '0')

  652.           luaL_addlstring(b, s, e - s);

  653.       else {

  654.         push_onecapture(ms, news[i] - '1', s, e);

  655.         luaL_addvalue(b);  /* add capture to accumulated result */

  656.       }

  657.     }

  658.   }

  659. }

  660. 

  661. 

  662. static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,

  663.                                        const char *e, int tr) {

  664.   lua_State *L = ms->L;

  665.   switch (tr) {

  666.     case LUA_TFUNCTION: {

  667.       int n;

  668.       lua_pushvalue(L, 3);

  669.       n = push_captures(ms, s, e);

  670.       lua_call(L, n, 1);

  671.       break;

  672.     }

  673.     case LUA_TTABLE: {

  674.       push_onecapture(ms, 0, s, e);

  675.       lua_gettable(L, 3);

  676.       break;

  677.     }

  678.     default: {  /* LUA_TNUMBER or LUA_TSTRING */

  679.       add_s(ms, b, s, e);

  680.       return;

  681.     }

  682.   }

  683.   if (!lua_toboolean(L, -1)) {  /* nil or false? */

  684.     lua_pop(L, 1);

  685.     lua_pushlstring(L, s, e - s);  /* keep original text */

  686.   }

  687.   else if (!lua_isstring(L, -1))

  688.     luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));

  689.   luaL_addvalue(b);  /* add result to accumulator */

  690. }

  691. 

  692. 

  693. static int str_gsub (lua_State *L) {

  694.   size_t srcl, lp;

  695.   const char *src = luaL_checklstring(L, 1, &srcl);

  696.   const char *p = luaL_checklstring(L, 2, &lp);

  697.   int tr = lua_type(L, 3);

  698.   size_t max_s = luaL_optinteger(L, 4, srcl+1);

  699.   int anchor = (*p == '^');

  700.   size_t n = 0;

  701.   MatchState ms;

  702.   luaL_Buffer b;

  703.   luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||

  704.                    tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,

  705.                       "string/function/table expected");

  706.   luaL_buffinit(L, &b);

  707.   if (anchor) {

  708.     p++; lp--;  /* skip anchor character */

  709.   }

  710.   ms.L = L;

  711.   ms.src_init = src;

  712.   ms.src_end = src+srcl;

  713.   ms.p_end = p + lp;

  714.   while (n < max_s) {

  715.     const char *e;

  716.     ms.level = 0;

  717.     e = match(&ms, src, p);

  718.     if (e) {

  719.       n++;

  720.       add_value(&ms, &b, src, e, tr);

  721.     }

  722.     if (e && e>src) /* non empty match? */

  723.       src = e;  /* skip it */

  724.     else if (src < ms.src_end)

  725.       luaL_addchar(&b, *src++);

  726.     else break;

  727.     if (anchor) break;

  728.   }

  729.   luaL_addlstring(&b, src, ms.src_end-src);

  730.   luaL_pushresult(&b);

  731.   lua_pushinteger(L, n);  /* number of substitutions */

  732.   return 2;

  733. }

  734. 

  735. /* }====================================================== */

  736. 

  737. 

  738. 

  739. /*

  740. ** {======================================================

  741. ** STRING FORMAT

  742. ** =======================================================

  743. */

  744. 

  745. /*

  746. ** LUA_INTFRMLEN is the length modifier for integer conversions in

  747. ** 'string.format'; LUA_INTFRM_T is the integer type corresponding to

  748. ** the previous length

  749. */

  750. #if !defined(LUA_INTFRMLEN)	/* { */

  751. #if defined(LUA_USE_LONGLONG)

  752. 

  753. #define LUA_INTFRMLEN		"ll"

  754. #define LUA_INTFRM_T		long long

  755. 

  756. #else

  757. 

  758. #define LUA_INTFRMLEN		"l"

  759. #define LUA_INTFRM_T		long

  760. 

  761. #endif

  762. #endif				/* } */

  763. 

  764. 

  765. /*

  766. ** LUA_FLTFRMLEN is the length modifier for float conversions in

  767. ** 'string.format'; LUA_FLTFRM_T is the float type corresponding to

  768. ** the previous length

  769. */

  770. #if !defined(LUA_FLTFRMLEN)

  771. 

  772. #define LUA_FLTFRMLEN		""

  773. #define LUA_FLTFRM_T		double

  774. 

  775. #endif

  776. 

  777. 

  778. /* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */

  779. #define MAX_ITEM	512

  780. /* valid flags in a format specification */

  781. #define FLAGS	"-+ #0"

  782. /*

  783. ** maximum size of each format specification (such as '%-099.99d')

  784. ** (+10 accounts for %99.99x plus margin of error)

  785. */

  786. #define MAX_FORMAT	(sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)

  787. 

  788. 

  789. static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {

  790.   size_t l;

  791.   const char *s = luaL_checklstring(L, arg, &l);

  792.   luaL_addchar(b, '"');

  793.   while (l--) {

  794.     if (*s == '"' || *s == '\\' || *s == '\n') {

  795.       luaL_addchar(b, '\\');

  796.       luaL_addchar(b, *s);

  797.     }

  798.     else if (*s == '\0' || iscntrl(uchar(*s))) {

  799.       char buff[10];

  800.       if (!isdigit(uchar(*(s+1))))

  801.         sprintf(buff, "\\%d", (int)uchar(*s));

  802.       else

  803.         sprintf(buff, "\\%03d", (int)uchar(*s));

  804.       luaL_addstring(b, buff);

  805.     }

  806.     else

  807.       luaL_addchar(b, *s);

  808.     s++;

  809.   }

  810.   luaL_addchar(b, '"');

  811. }

  812. 

  813. static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {

  814.   const char *p = strfrmt;

  815.   while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */

  816.   if ((size_t)(p - strfrmt) >= sizeof(FLAGS)/sizeof(char))

  817.     luaL_error(L, "invalid format (repeated flags)");

  818.   if (isdigit(uchar(*p))) p++;  /* skip width */

  819.   if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */

  820.   if (*p == '.') {

  821.     p++;

  822.     if (isdigit(uchar(*p))) p++;  /* skip precision */

  823.     if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */

  824.   }

  825.   if (isdigit(uchar(*p)))

  826.     luaL_error(L, "invalid format (width or precision too long)");

  827.   *(form++) = '%';

  828.   memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char));

  829.   form += p - strfrmt + 1;

  830.   *form = '\0';

  831.   return p;

  832. }

  833. 

  834. 

  835. /*

  836. ** add length modifier into formats

  837. */

  838. static void addlenmod (char *form, const char *lenmod) {

  839.   size_t l = strlen(form);

  840.   size_t lm = strlen(lenmod);

  841.   char spec = form[l - 1];

  842.   strcpy(form + l - 1, lenmod);

  843.   form[l + lm - 1] = spec;

  844.   form[l + lm] = '\0';

  845. }

  846. 

  847. 

  848. static int str_format (lua_State *L) {

  849.   int top = lua_gettop(L);

  850.   int arg = 1;

  851.   size_t sfl;

  852.   const char *strfrmt = luaL_checklstring(L, arg, &sfl);

  853.   const char *strfrmt_end = strfrmt+sfl;

  854.   luaL_Buffer b;

  855.   luaL_buffinit(L, &b);

  856.   while (strfrmt < strfrmt_end) {

  857.     if (*strfrmt != L_ESC)

  858.       luaL_addchar(&b, *strfrmt++);

  859.     else if (*++strfrmt == L_ESC)

  860.       luaL_addchar(&b, *strfrmt++);  /* %% */

  861.     else { /* format item */

  862.       char form[MAX_FORMAT];  /* to store the format (`%...') */

  863.       char *buff = luaL_prepbuffsize(&b, MAX_ITEM);  /* to put formatted item */

  864.       int nb = 0;  /* number of bytes in added item */

  865.       if (++arg > top)

  866.         luaL_argerror(L, arg, "no value");

  867.       strfrmt = scanformat(L, strfrmt, form);

  868.       switch (*strfrmt++) {

  869.         case 'c': {

  870.           nb = sprintf(buff, form, luaL_checkint(L, arg));

  871.           break;

  872.         }

  873.         case 'd':  case 'i': {

  874.           lua_Number n = luaL_checknumber(L, arg);

  875.           LUA_INTFRM_T ni = (LUA_INTFRM_T)n;

  876.           lua_Number diff = n - (lua_Number)ni;

  877.           luaL_argcheck(L, -1 < diff && diff < 1, arg,

  878.                         "not a number in proper range");

  879.           addlenmod(form, LUA_INTFRMLEN);

  880.           nb = sprintf(buff, form, ni);

  881.           break;

  882.         }

  883.         case 'o':  case 'u':  case 'x':  case 'X': {

  884.           lua_Number n = luaL_checknumber(L, arg);

  885.           unsigned LUA_INTFRM_T ni = (unsigned LUA_INTFRM_T)n;

  886.           lua_Number diff = n - (lua_Number)ni;

  887.           luaL_argcheck(L, -1 < diff && diff < 1, arg,

  888.                         "not a non-negative number in proper range");

  889.           addlenmod(form, LUA_INTFRMLEN);

  890.           nb = sprintf(buff, form, ni);

  891.           break;

  892.         }

  893.         case 'e':  case 'E': case 'f':

  894. #if defined(LUA_USE_AFORMAT)

  895.         case 'a': case 'A':

  896. #endif

  897.         case 'g': case 'G': {

  898.           addlenmod(form, LUA_FLTFRMLEN);

  899.           nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));

  900.           break;

  901.         }

  902.         case 'q': {

  903.           addquoted(L, &b, arg);

  904.           break;

  905.         }

  906.         case 's': {

  907.           size_t l;

  908.           const char *s = luaL_tolstring(L, arg, &l);

  909.           if (!strchr(form, '.') && l >= 100) {

  910.             /* no precision and string is too long to be formatted;

  911.                keep original string */

  912.             luaL_addvalue(&b);

  913.             break;

  914.           }

  915.           else {

  916.             nb = sprintf(buff, form, s);

  917.             lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */

  918.             break;

  919.           }

  920.         }

  921.         default: {  /* also treat cases `pnLlh' */

  922.           return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "

  923.                                LUA_QL("format"), *(strfrmt - 1));

  924.         }

  925.       }

  926.       luaL_addsize(&b, nb);

  927.     }

  928.   }

  929.   luaL_pushresult(&b);

  930.   return 1;

  931. }

  932. 

  933. /* }====================================================== */

  934. 

  935. 

  936. static const luaL_Reg strlib[] = {

  937.   {"byte", str_byte},

  938.   {"char", str_char},

  939.   {"dump", str_dump},

  940.   {"find", str_find},

  941.   {"format", str_format},

  942.   {"gmatch", gmatch},

  943.   {"gsub", str_gsub},

  944.   {"len", str_len},

  945.   {"lower", str_lower},

  946.   {"match", str_match},

  947.   {"rep", str_rep},

  948.   {"reverse", str_reverse},

  949.   {"sub", str_sub},

  950.   {"upper", str_upper},

  951.   {NULL, NULL}

  952. };

  953. 

  954. 

  955. static void createmetatable (lua_State *L) {

  956.   lua_createtable(L, 0, 1);  /* table to be metatable for strings */

  957.   lua_pushliteral(L, "");  /* dummy string */

  958.   lua_pushvalue(L, -2);  /* copy table */

  959.   lua_setmetatable(L, -2);  /* set table as metatable for strings */

  960.   lua_pop(L, 1);  /* pop dummy string */

  961.   lua_pushvalue(L, -2);  /* get string library */

  962.   lua_setfield(L, -2, "__index");  /* metatable.__index = string */

  963.   lua_pop(L, 1);  /* pop metatable */

  964. }

  965. 

  966. 

  967. /*

  968. ** Open string library

  969. */

  970. LUAMOD_API int luaopen_string (lua_State *L) {

  971.   luaL_newlib(L, strlib);

  972.   createmetatable(L);

  973.   return 1;

  974. }