if ((size_t)(cap->src_end-s) >= len &&      memcmp(cap->capture[l].init, s, len) == 0)    return s+len;  else return NULL;}static const char *match (lua_State *L, const char *s, const char *p,                          struct Capture *cap) {  init: /* using goto's to optimize tail recursion */  switch (*p) {    case '(':  /* start capture */      return start_capture(L, s, p, cap);    case ')':  /* end capture */      return end_capture(L, s, p, cap);    case ESC:  /* may be %[0-9] or %b */      if (isdigit((unsigned char)(*(p+1)))) {  /* capture? */        s = match_capture(L, s, *(p+1), cap);        if (s == NULL) return NULL;        p+=2; goto init;  /* else return match(L, s, p+2, cap) */      }      else if (*(p+1) == 'b') {  /* balanced string? */        s = matchbalance(L, s, p+2, cap);        if (s == NULL) return NULL;        p+=4; goto init;  /* else return match(L, s, p+4, cap); */      }      else goto dflt;  /* case default */    case '\0':  /* end of pattern */      return s;  /* match succeeded */    case '$':      if (*(p+1) == '\0')  /* is the '$' the last char in pattern? */        return (s == cap->src_end) ? s : NULL;  /* check end of string */      else goto dflt;    default: dflt: {  /* it is a pattern item */      const char *ep = luaI_classend(L, p);  /* points to what is next */      int m = s<cap->src_end && luaI_singlematch((unsigned char)*s, p, ep);      switch (*ep) {        case '?': {  /* optional */          const char *res;          if (m && ((res=match(L, s+1, ep+1, cap)) != NULL))            return res;          p=ep+1; goto init;  /* else return match(L, s, ep+1, cap); */        }        case '*':  /* 0 or more repetitions */          return max_expand(L, s, p, ep, cap);        case '+':  /* 1 or more repetitions */          return (m ? max_expand(L, s+1, p, ep, cap) : NULL);        case '-':  /* 0 or more repetitions (minimum) */          return min_expand(L, s, p, ep, cap);        default:          if (!m) return NULL;          s++; p=ep; goto init;  /* else return match(L, s+1, ep, cap); */      }    }  }}static const char *lmemfind (const char *s1, size_t l1,                             const char *s2, size_t l2) {  if (l2 == 0) return s1;  /* empty strings are everywhere */  else if (l2 > l1) return NULL;  /* avoids a negative `l1' */  else {    const char *init;  /* to search for a `*s2' inside `s1' */    l2--;  /* 1st char will be checked by `memchr' */    l1 = l1-l2;  /* `s2' cannot be found after that */    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {      init++;   /* 1st char is already checked */      if (memcmp(init, s2+1, l2) == 0)        return init-1;      else {  /* correct `l1' and `s1' to try again */        l1 -= init-s1;        s1 = init;      }    }    return NULL;  /* not found */  }}static int push_captures (lua_State *L, struct Capture *cap) {  int i;  luaL_checkstack(L, cap->level, "too many captures");  for (i=0; i<cap->level; i++) {    int l = cap->capture[i].len;    if (l == -1) lua_error(L, "unfinished capture");    lua_pushlstring(L, cap->capture[i].init, l);  }  return cap->level;  /* number of strings pushed */}static int str_find (lua_State *L) {  size_t l1, l2;  const char *s = luaL_check_lstr(L, 1, &l1);  const char *p = luaL_check_lstr(L, 2, &l2);  long init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1;  struct Capture cap;  luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, "out of range");  if (lua_gettop(L) > 3 ||  /* extra argument? */      strpbrk(p, SPECIALS) == NULL) {  /* or no special characters? */    const char *s2 = lmemfind(s+init, l1-init, p, l2);    if (s2) {      lua_pushnumber(L, s2-s+1);      lua_pushnumber(L, s2-s+l2);      return 2;    }  }  else {    int anchor = (*p == '^') ? (p++, 1) : 0;    const char *s1=s+init;    cap.src_end = s+l1;    do {      const char *res;      cap.level = 0;      if ((res=match(L, s1, p, &cap)) != NULL) {        lua_pushnumber(L, s1-s+1);  /* start */        lua_pushnumber(L, res-s);   /* end */        return push_captures(L, &cap) + 2;      }    } while (s1++<cap.src_end && !anchor);  }  lua_pushnil(L);  /* not found */  return 1;}static void add_s (lua_State *L, luaL_Buffer *b, struct Capture *cap) {  if (lua_isstring(L, 3)) {    const char *news = lua_tostring(L, 3);    size_t l = lua_strlen(L, 3);    size_t i;    for (i=0; i<l; i++) {      if (news[i] != ESC)        luaL_putchar(b, news[i]);      else {        i++;  /* skip ESC */        if (!isdigit((unsigned char)news[i]))          luaL_putchar(b, news[i]);        else {          int level = check_capture(L, news[i], cap);          luaL_addlstring(b, cap->capture[level].init, cap->capture[level].len);        }      }    }  }  else {  /* is a function */    int n;    lua_pushvalue(L, 3);    n = push_captures(L, cap);    lua_rawcall(L, n, 1);    if (lua_isstring(L, -1))      luaL_addvalue(b);  /* add return to accumulated result */    else      lua_pop(L, 1);  /* function result is not a string: pop it */  }}static int str_gsub (lua_State *L) {  size_t srcl;  const char *src = luaL_check_lstr(L, 1, &srcl);  const char *p = luaL_check_string(L, 2);  int max_s = luaL_opt_int(L, 4, srcl+1);  int anchor = (*p == '^') ? (p++, 1) : 0;  int n = 0;  struct Capture cap;  luaL_Buffer b;  luaL_arg_check(L,    lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)),    3, "string or function expected");  luaL_buffinit(L, &b);  cap.src_end = src+srcl;  while (n < max_s) {    const char *e;    cap.level = 0;    e = match(L, src, p, &cap);    if (e) {      n++;      add_s(L, &b, &cap);    }    if (e && e>src) /* non empty match? */      src = e;  /* skip it */    else if (src < cap.src_end)      luaL_putchar(&b, *src++);    else break;    if (anchor) break;  }  luaL_addlstring(&b, src, cap.src_end-src);  luaL_pushresult(&b);  lua_pushnumber(L, n);  /* number of substitutions */  return 2;}/* }====================================================== */static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) {  size_t l;  const char *s = luaL_check_lstr(L, arg, &l);  luaL_putchar(b, '"');  while (l--) {    switch (*s) {      case '"':  case '\\':  case '\n':        luaL_putchar(b, '\\');        luaL_putchar(b, *s);        break;      case '\0': luaL_addlstring(b, "\\000", 4); break;      default: luaL_putchar(b, *s);    }    s++;  }  luaL_putchar(b, '"');}/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */#define MAX_ITEM	512/* maximum size of each format specification (such as '%-099.99d') */#define MAX_FORMAT	20static int str_format (lua_State *L) {  int arg = 1;  const char *strfrmt = luaL_check_string(L, arg);  luaL_Buffer b;  luaL_buffinit(L, &b);  while (*strfrmt) {    if (*strfrmt != '%')      luaL_putchar(&b, *strfrmt++);    else if (*++strfrmt == '%')      luaL_putchar(&b, *strfrmt++);  /* %% */    else { /* format item */      struct Capture cap;      char form[MAX_FORMAT];  /* to store the format ('%...') */      char buff[MAX_ITEM];  /* to store the formatted item */      const char *initf = strfrmt;      form[0] = '%';      if (isdigit((unsigned char)*initf) && *(initf+1) == '$') {        arg = *initf - '0';        initf += 2;  /* skip the 'n$' */      }      arg++;      cap.src_end = strfrmt+strlen(strfrmt)+1;      cap.level = 0;      strfrmt = match(L, initf, "[-+ #0]*(%d*)%.?(%d*)", &cap);      if (cap.capture[0].len > 2 || cap.capture[1].len > 2 ||  /* < 100? */          strfrmt-initf > MAX_FORMAT-2)        lua_error(L, "invalid format (width or precision too long)");      strncpy(form+1, initf, strfrmt-initf+1); /* +1 to include conversion */      form[strfrmt-initf+2] = 0;      switch (*strfrmt++) {        case 'c':  case 'd':  case 'i':          sprintf(buff, form, luaL_check_int(L, arg));          break;        case 'o':  case 'u':  case 'x':  case 'X':          sprintf(buff, form, (unsigned int)luaL_check_number(L, arg));          break;        case 'e':  case 'E': case 'f': case 'g': case 'G':          sprintf(buff, form, luaL_check_number(L, arg));          break;        case 'q':          luaI_addquoted(L, &b, arg);          continue;  /* skip the "addsize" at the end */        case 's': {          size_t l;          const char *s = luaL_check_lstr(L, arg, &l);          if (cap.capture[1].len == 0 && l >= 100) {            /* no precision and string is too long to be formatted;               keep original string */            lua_pushvalue(L, arg);            luaL_addvalue(&b);            continue;  /* skip the "addsize" at the end */          }          else {            sprintf(buff, form, s);            break;          }        }        default:  /* also treat cases 'pnLlh' */          lua_error(L, "invalid option in `format'");      }      luaL_addlstring(&b, buff, strlen(buff));    }  }  luaL_pushresult(&b);  return 1;}static const struct luaL_reg strlib[] = {{"strlen", str_len},{"strsub", str_sub},{"strlower", str_lower},{"strupper", str_upper},{"strchar", str_char},{"strrep", str_rep},{"ascii", str_byte},  /* for compatibility with 3.0 and earlier */{"strbyte", str_byte},{"format", str_format},{"strfind", str_find},{"gsub", str_gsub}};/*** Open string library*/LUALIB_API void lua_strlibopen (lua_State *L) {  luaL_openl(L, strlib);}