Lua 3.13.1

5 files changed, 1234 insertions, 0 deletions

diff --git a/src/lib/Makefile b/src/lib/Makefile
new file mode 100644
index 00000000..70db660f
--- /dev/null
+++ b/src/lib/Makefile
@@ -0,0 +1,28 @@
+# makefile for lua standard library
+
+LUA= ../..
+
+include $(LUA)/config
+
+# actually only used in liolib.c
+EXTRA_DEFS= $(POPEN)
+
+OBJS= liolib.o lmathlib.o lstrlib.o
+SRCS= liolib.c lmathlib.c lstrlib.c
+
+T= $(LIB)/liblualib.a
+
+all: $T
+
+$T: $(OBJS)
+	$(AR) $@ $(OBJS)
+	$(RANLIB) $@
+
+clean:
+	rm -f $(OBJS) $T
+
+co:
+	co -q -f -M $(SRCS)
+
+klean:	clean
+	rm -f $(SRCS)
diff --git a/src/lib/README b/src/lib/README
new file mode 100644
index 00000000..e8e599c8
--- /dev/null
+++ b/src/lib/README
@@ -0,0 +1,4 @@
+This is the standard Lua library.
+It is implemented entirely on top of the official Lua API as declared in lua.h,
+using src/lauxlib.c, which contains several useful functions.
+The code can be read as an example of how to export C functions to Lua.
diff --git a/src/lib/liolib.c b/src/lib/liolib.c
new file mode 100644
index 00000000..15ea6587
--- /dev/null
+++ b/src/lib/liolib.c
@@ -0,0 +1,448 @@
+/*
+** $Id: liolib.c,v 1.21 1998/06/18 17:04:28 roberto Exp $
+** Standard I/O (and system) library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "lauxlib.h"
+#include "lua.h"
+#include "luadebug.h"
+#include "lualib.h"
+
+
+#ifndef OLD_ANSI
+#include <locale.h>
+#else
+#define setlocale(a,b)	0
+#define LC_ALL		0
+#define LC_COLLATE	0
+#define LC_CTYPE	0
+#define LC_MONETARY	0
+#define LC_NUMERIC	0
+#define LC_TIME		0
+#define strerror(e)	"(no error message provided by operating system)"
+#endif
+
+
+#define CLOSEDTAG	2
+#define IOTAG		1
+
+#define FIRSTARG      3  /* 1st and 2nd are upvalues */
+
+#define FINPUT		"_INPUT"
+#define FOUTPUT		"_OUTPUT"
+
+
+#ifdef POPEN
+FILE *popen();
+int pclose();
+#else
+#define popen(x,y) NULL  /* that is, popen always fails */
+#define pclose(x)  (-1)
+#endif
+
+
+static int gettag (int i)
+{
+  return lua_getnumber(lua_getparam(i));
+}
+
+
+static void pushresult (int i)
+{
+  if (i)
+    lua_pushuserdata(NULL);
+  else {
+    lua_pushnil();
+    lua_pushstring(strerror(errno));
+  }
+}
+
+
+static int ishandler (lua_Object f)
+{
+  if (lua_isuserdata(f)) {
+    if (lua_tag(f) == gettag(CLOSEDTAG))
+      lua_error("cannot access a closed file");
+    return lua_tag(f) == gettag(IOTAG);
+  }
+  else return 0;
+}
+
+static FILE *getfile (char *name)
+{
+  lua_Object f = lua_getglobal(name);
+  if (!ishandler(f))
+      luaL_verror("global variable `%.50s' is not a file handle", name);
+  return lua_getuserdata(f);
+}
+
+
+static FILE *getfileparam (char *name, int *arg)
+{
+  lua_Object f = lua_getparam(*arg);
+  if (ishandler(f)) {
+    (*arg)++;
+    return lua_getuserdata(f);
+  }
+  else
+    return getfile(name);
+}
+
+
+static void closefile (char *name)
+{
+  FILE *f = getfile(name);
+  if (f == stdin || f == stdout) return;
+  if (pclose(f) == -1)
+    fclose(f);
+  lua_pushobject(lua_getglobal(name));
+  lua_settag(gettag(CLOSEDTAG));
+}
+
+
+static void setfile (FILE *f, char *name, int tag)
+{
+  lua_pushusertag(f, tag);
+  lua_setglobal(name);
+}
+
+
+static void setreturn (FILE *f, char *name)
+{
+  int tag = gettag(IOTAG);
+  setfile(f, name, tag);
+  lua_pushusertag(f, tag);
+}
+
+
+static void io_readfrom (void)
+{
+  FILE *current;
+  lua_Object f = lua_getparam(FIRSTARG);
+  if (f == LUA_NOOBJECT) {
+    closefile(FINPUT);
+    current = stdin;
+  }
+  else if (lua_tag(f) == gettag(IOTAG))
+    current = lua_getuserdata(f);
+  else {
+    char *s = luaL_check_string(FIRSTARG);
+    current = (*s == '|') ? popen(s+1, "r") : fopen(s, "r");
+    if (current == NULL) {
+      pushresult(0);
+      return;
+    }
+  }
+  setreturn(current, FINPUT);
+}
+
+
+static void io_writeto (void)
+{
+  FILE *current;
+  lua_Object f = lua_getparam(FIRSTARG);
+  if (f == LUA_NOOBJECT) {
+    closefile(FOUTPUT);
+    current = stdout;
+  }
+  else if (lua_tag(f) == gettag(IOTAG))
+    current = lua_getuserdata(f);
+  else {
+    char *s = luaL_check_string(FIRSTARG);
+    current = (*s == '|') ? popen(s+1,"w") : fopen(s,"w");
+    if (current == NULL) {
+      pushresult(0);
+      return;
+    }
+  }
+  setreturn(current, FOUTPUT);
+}
+
+
+static void io_appendto (void)
+{
+  char *s = luaL_check_string(FIRSTARG);
+  FILE *fp = fopen (s, "a");
+  if (fp != NULL)
+    setreturn(fp, FOUTPUT);
+  else
+    pushresult(0);
+}
+
+
+#define NEED_OTHER (EOF-1)  /* just some flag different from EOF */
+
+
+static void read_until (FILE *f, int lim) {
+  int l = 0;
+  int c;
+  for (c = getc(f); c != EOF && c != lim; c = getc(f)) {
+    luaL_addchar(c);
+    l++;
+  }
+  if (l > 0 || c == lim)  /* read anything? */
+    lua_pushlstring(luaL_buffer(), l);
+}
+
+static void io_read (void) {
+  int arg = FIRSTARG;
+  FILE *f = getfileparam(FINPUT, &arg);
+  char *p = luaL_opt_string(arg, NULL);
+  luaL_resetbuffer();
+  if (p == NULL)  /* default: read a line */
+    read_until(f, '\n');
+  else if (p[0] == '.' && p[1] == '*' && p[2] == 0)  /* p = ".*" */
+    read_until(f, EOF);
+  else {
+    int l = 0;  /* number of chars read in buffer */
+    int inskip = 0;  /* to control {skips} */
+    int c = NEED_OTHER;
+    while (*p) {
+      switch (*p) {
+        case '{':
+          inskip++;
+          p++;
+          continue;
+        case '}':
+          if (inskip == 0)
+            lua_error("unbalanced braces in read pattern");
+          inskip--;
+          p++;
+          continue;
+        default: {
+          char *ep;  /* get what is next */
+          int m;  /* match result */
+          if (c == NEED_OTHER) c = getc(f);
+          if (c == EOF) {
+            luaI_singlematch(0, p, &ep);  /* to set "ep" */
+            m = 0;
+          }
+          else {
+            m = luaI_singlematch(c, p, &ep);
+            if (m) {
+              if (inskip == 0) {
+                luaL_addchar(c);
+                l++;
+              }
+              c = NEED_OTHER;
+            }
+          }
+          switch (*ep) {
+            case '*':  /* repetition */
+              if (!m) p = ep+1;  /* else stay in (repeat) the same item */
+              continue;
+            case '?':  /* optional */
+              p = ep+1;  /* continues reading the pattern */
+              continue;
+            default:
+              if (m) p = ep;  /* continues reading the pattern */
+              else
+                goto break_while;   /* pattern fails */
+          }
+        }
+      }
+    } break_while:
+    if (c >= 0)  /* not EOF nor NEED_OTHER? */
+       ungetc(c, f);
+    if (l > 0 || *p == 0)  /* read something or did not fail? */
+      lua_pushlstring(luaL_buffer(), l);
+  }
+}
+
+
+static void io_write (void)
+{
+  int arg = FIRSTARG;
+  FILE *f = getfileparam(FOUTPUT, &arg);
+  int status = 1;
+  char *s;
+  long l;
+  while ((s = luaL_opt_lstr(arg++, NULL, &l)) != NULL)
+    status = status && (fwrite(s, 1, l, f) == l);
+  pushresult(status);
+}
+
+
+static void io_execute (void)
+{
+  lua_pushnumber(system(luaL_check_string(1)));
+}
+
+
+static void io_remove  (void)
+{
+  pushresult(remove(luaL_check_string(1)) == 0);
+}
+
+
+static void io_rename (void)
+{
+  pushresult(rename(luaL_check_string(1),
+                    luaL_check_string(2)) == 0);
+}
+
+
+static void io_tmpname (void)
+{
+  lua_pushstring(tmpnam(NULL));
+}
+
+
+
+static void io_getenv (void)
+{
+  lua_pushstring(getenv(luaL_check_string(1)));  /* if NULL push nil */
+}
+
+
+static void io_clock (void) {
+  lua_pushnumber(((double)clock())/CLOCKS_PER_SEC);
+}
+
+
+static void io_date (void)
+{
+  time_t t;
+  struct tm *tm;
+  char *s = luaL_opt_string(1, "%c");
+  char b[BUFSIZ];
+  time(&t); tm = localtime(&t);
+  if (strftime(b,sizeof(b),s,tm))
+    lua_pushstring(b);
+  else
+    lua_error("invalid `date' format");
+}
+
+
+static void setloc (void)
+{
+  static int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC,
+                      LC_TIME};
+  static char *catnames[] = {"all", "collate", "ctype", "monetary",
+     "numeric", "time", NULL};
+  int op = luaL_findstring(luaL_opt_string(2, "all"), catnames);
+  luaL_arg_check(op != -1, 2, "invalid option");
+  lua_pushstring(setlocale(cat[op], luaL_check_string(1)));
+}
+
+
+static void io_exit (void)
+{
+  lua_Object o = lua_getparam(1);
+  exit(lua_isnumber(o) ? (int)lua_getnumber(o) : 1);
+}
+
+
+static void io_debug (void)
+{
+  while (1) {
+    char buffer[250];
+    fprintf(stderr, "lua_debug> ");
+    if (fgets(buffer, sizeof(buffer), stdin) == 0) return;
+    if (strcmp(buffer, "cont\n") == 0) return;
+    lua_dostring(buffer);
+  }
+}
+
+
+static void lua_printstack (FILE *f)
+{
+  int level = 1;  /* skip level 0 (it's this function) */
+  lua_Object func;
+  while ((func = lua_stackedfunction(level++)) != LUA_NOOBJECT) {
+    char *name;
+    int currentline;
+    char *filename;
+    int linedefined;
+    lua_funcinfo(func, &filename, &linedefined);
+    fprintf(f, (level==2) ? "Active Stack:\n\t" : "\t");
+    switch (*lua_getobjname(func, &name)) {
+      case 'g':
+        fprintf(f, "function %s", name);
+        break;
+      case 't':
+        fprintf(f, "`%s' tag method", name);
+        break;
+      default: {
+        if (linedefined == 0)
+          fprintf(f, "main of %s", filename);
+        else if (linedefined < 0)
+          fprintf(f, "%s", filename);
+        else
+          fprintf(f, "function (%s:%d)", filename, linedefined);
+        filename = NULL;
+      }
+    }
+    if ((currentline = lua_currentline(func)) > 0)
+      fprintf(f, " at line %d", currentline);
+    if (filename)
+      fprintf(f, " [in file %s]", filename);
+    fprintf(f, "\n");
+  }
+}
+
+
+static void errorfb (void)
+{
+  fprintf(stderr, "lua: %s\n", lua_getstring(lua_getparam(1)));
+  lua_printstack(stderr);
+}
+
+
+
+static struct luaL_reg iolib[] = {
+{"setlocale", setloc},
+{"execute",  io_execute},
+{"remove",   io_remove},
+{"rename",   io_rename},
+{"tmpname",   io_tmpname},
+{"getenv",   io_getenv},
+{"date",     io_date},
+{"clock",     io_clock},
+{"exit",     io_exit},
+{"debug",    io_debug},
+{"print_stack", errorfb}
+};
+
+static struct luaL_reg iolibtag[] = {
+{"readfrom", io_readfrom},
+{"writeto",  io_writeto},
+{"appendto", io_appendto},
+{"read",     io_read},
+{"write",    io_write}
+};
+
+static void openwithtags (void)
+{
+  int iotag = lua_newtag();
+  int closedtag = lua_newtag();
+  int i;
+  for (i=0; i<sizeof(iolibtag)/sizeof(iolibtag[0]); i++) {
+    /* put both tags as upvalues for these functions */
+    lua_pushnumber(iotag);
+    lua_pushnumber(closedtag);
+    lua_pushcclosure(iolibtag[i].func, 2);
+    lua_setglobal(iolibtag[i].name);
+  }
+  setfile(stdin, FINPUT, iotag);
+  setfile(stdout, FOUTPUT, iotag);
+  setfile(stdin, "_STDIN", iotag);
+  setfile(stdout, "_STDOUT", iotag);
+  setfile(stderr, "_STDERR", iotag);
+}
+
+void lua_iolibopen (void)
+{
+  luaL_openlib(iolib, (sizeof(iolib)/sizeof(iolib[0])));
+  openwithtags();
+  lua_pushcfunction(errorfb);
+  lua_seterrormethod();
+}
diff --git a/src/lib/lmathlib.c b/src/lib/lmathlib.c
new file mode 100644
index 00000000..bdc534f5
--- /dev/null
+++ b/src/lib/lmathlib.c
@@ -0,0 +1,213 @@
+/*
+** $Id: lmathlib.c,v 1.10 1998/06/19 16:14:09 roberto Exp $
+** Lua standard mathematical library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdlib.h>
+#include <math.h>
+
+#include "lauxlib.h"
+#include "lua.h"
+#include "lualib.h"
+
+#ifdef M_PI
+#define PI                      M_PI
+#else
+#define PI          ((double)3.14159265358979323846)
+#endif
+
+
+#define FROMRAD(a) ((a)*(180.0/PI))
+#define TORAD(a)    ((a)*(PI/180.0))
+
+
+static void math_abs (void)
+{
+  double d = luaL_check_number(1);
+  if (d < 0) d = -d;
+  lua_pushnumber(d);
+}
+
+static void math_sin (void)
+{
+  lua_pushnumber(sin(TORAD(luaL_check_number(1))));
+}
+
+static void math_cos (void)
+{
+  lua_pushnumber(cos(TORAD(luaL_check_number(1))));
+}
+
+static void math_tan (void)
+{
+  lua_pushnumber(tan(TORAD(luaL_check_number(1))));
+}
+
+static void math_asin (void)
+{
+  lua_pushnumber(FROMRAD(asin(luaL_check_number(1))));
+}
+
+static void math_acos (void)
+{
+  lua_pushnumber(FROMRAD(acos(luaL_check_number(1))));
+}
+
+static void math_atan (void)
+{
+  lua_pushnumber(FROMRAD(atan(luaL_check_number(1))));
+}
+
+static void math_atan2 (void)
+{
+  lua_pushnumber(FROMRAD(atan2(luaL_check_number(1), luaL_check_number(2))));
+}
+
+static void math_ceil (void)
+{
+  lua_pushnumber(ceil(luaL_check_number(1)));
+}
+
+static void math_floor (void)
+{
+  lua_pushnumber(floor(luaL_check_number(1)));
+}
+
+static void math_mod (void)
+{
+  lua_pushnumber(fmod(luaL_check_number(1), luaL_check_number(2)));
+}
+
+static void math_sqrt (void)
+{
+  lua_pushnumber(sqrt(luaL_check_number(1)));
+}
+
+static void math_pow (void)
+{
+  lua_pushnumber(pow(luaL_check_number(1), luaL_check_number(2)));
+}
+
+static void math_log (void)
+{
+  lua_pushnumber(log(luaL_check_number(1)));
+}
+
+static void math_log10 (void)
+{
+  lua_pushnumber(log10(luaL_check_number(1)));
+}
+
+static void math_exp (void)
+{
+  lua_pushnumber(exp(luaL_check_number(1)));
+}
+
+static void math_deg (void)
+{
+  lua_pushnumber(luaL_check_number(1)*(180.0/PI));
+}
+
+static void math_rad (void)
+{
+  lua_pushnumber(luaL_check_number(1)*(PI/180.0));
+}
+
+static void math_frexp (void) {
+  int e;
+  lua_pushnumber(frexp(luaL_check_number(1), &e));
+  lua_pushnumber(e);
+}
+
+static void math_ldexp (void) {
+  lua_pushnumber(ldexp(luaL_check_number(1), luaL_check_number(2)));
+}
+
+
+
+static void math_min (void)
+{
+  int i = 1;
+  double dmin = luaL_check_number(i);
+  while (lua_getparam(++i) != LUA_NOOBJECT) {
+    double d = luaL_check_number(i);
+    if (d < dmin)
+      dmin = d;
+  }
+  lua_pushnumber(dmin);
+}
+
+
+static void math_max (void)
+{
+  int i = 1;
+  double dmax = luaL_check_number(i);
+  while (lua_getparam(++i) != LUA_NOOBJECT) {
+    double d = luaL_check_number(i);
+    if (d > dmax)
+      dmax = d;
+  }
+  lua_pushnumber(dmax);
+}
+
+
+static void math_random (void)
+{
+  /* the '%' is needed because on some systems (SunOS!) "rand()" may */
+  /* return a value bigger than RAND_MAX... */
+  double r = (double)(rand()%RAND_MAX) / (double)RAND_MAX;
+  double l = luaL_opt_number(1, 0);
+  if (l == 0)
+    lua_pushnumber(r);
+  else
+    lua_pushnumber((int)(r*l)+1);
+}
+
+
+static void math_randomseed (void)
+{
+  srand(luaL_check_number(1));
+}
+
+
+static struct luaL_reg mathlib[] = {
+{"abs",   math_abs},
+{"sin",   math_sin},
+{"cos",   math_cos},
+{"tan",   math_tan},
+{"asin",  math_asin},
+{"acos",  math_acos},
+{"atan",  math_atan},
+{"atan2", math_atan2},
+{"ceil",  math_ceil},
+{"floor", math_floor},
+{"mod",   math_mod},
+{"frexp", math_frexp},
+{"ldexp", math_ldexp},
+{"sqrt",  math_sqrt},
+{"min",   math_min},
+{"max",   math_max},
+{"log",   math_log},
+{"log10", math_log10},
+{"exp",   math_exp},
+{"deg",   math_deg},
+{"rad",   math_rad},
+{"random",     math_random},
+{"randomseed", math_randomseed}
+};
+
+/*
+** Open math library
+*/
+void lua_mathlibopen (void)
+{
+  luaL_openlib(mathlib, (sizeof(mathlib)/sizeof(mathlib[0])));
+  lua_pushstring("deg"); lua_setglobal("_TRIGMODE");
+  lua_pushcfunction(math_pow);
+  lua_pushnumber(0);  /* to get its tag */
+  lua_settagmethod(lua_tag(lua_pop()), "pow");
+  lua_pushnumber(PI); lua_setglobal("PI");
+}
+
diff --git a/src/lib/lstrlib.c b/src/lib/lstrlib.c
new file mode 100644
index 00000000..dc79cc7e
--- /dev/null
+++ b/src/lib/lstrlib.c
@@ -0,0 +1,541 @@
+/*
+** $Id: lstrlib.c,v 1.18 1998/07/01 14:21:57 roberto Exp $
+** Standard library for strings and pattern-matching
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lauxlib.h"
+#include "lua.h"
+#include "lualib.h"
+
+
+
+static void addnchar (char *s, int n)
+{
+  char *b = luaL_openspace(n);
+  memcpy(b, s, n);
+  luaL_addsize(n);
+}
+
+
+static void str_len (void)
+{
+  long l;
+  luaL_check_lstr(1, &l);
+  lua_pushnumber(l);
+}
+
+
+static void closeandpush (void)
+{
+  lua_pushlstring(luaL_buffer(), luaL_getsize());
+}
+
+
+static long posrelat (long pos, long len)
+{
+  /* relative string position: negative means back from end */
+  return (pos>=0) ? pos : len+pos+1;
+}
+
+
+static void str_sub (void)
+{
+  long l;
+  char *s = luaL_check_lstr(1, &l);
+  long start = posrelat(luaL_check_number(2), l);
+  long end = posrelat(luaL_opt_number(3, -1), l);
+  if (1 <= start && start <= end && end <= l)
+    lua_pushlstring(s+start-1, end-start+1);
+  else lua_pushstring("");
+}
+
+
+static void str_lower (void)
+{
+  long l;
+  int i;
+  char *s = luaL_check_lstr(1, &l);
+  luaL_resetbuffer();
+  for (i=0; i<l; i++)
+    luaL_addchar(tolower((unsigned char)(s[i])));
+  closeandpush();
+}
+
+
+static void str_upper (void)
+{
+  long l;
+  int i;
+  char *s = luaL_check_lstr(1, &l);
+  luaL_resetbuffer();
+  for (i=0; i<l; i++)
+    luaL_addchar(toupper((unsigned char)(s[i])));
+  closeandpush();
+}
+
+static void str_rep (void)
+{
+  long l;
+  char *s = luaL_check_lstr(1, &l);
+  int n = (int)luaL_check_number(2);
+  luaL_resetbuffer();
+  while (n-- > 0)
+    addnchar(s, l);
+  closeandpush();
+}
+
+
+static void str_byte (void)
+{
+  long l;
+  char *s = luaL_check_lstr(1, &l);
+  long pos = posrelat(luaL_opt_number(2, 1), l);
+  luaL_arg_check(0<pos && pos<=l, 2,  "out of range");
+  lua_pushnumber((unsigned char)s[pos-1]);
+}
+
+static void str_char (void) {
+  int i = 0;
+  luaL_resetbuffer();
+  while (lua_getparam(++i) != LUA_NOOBJECT) {
+    double c = luaL_check_number(i);
+    luaL_arg_check((unsigned char)c == c, i, "invalid value");
+    luaL_addchar((int)c);
+  }
+  closeandpush();
+}
+
+
+/*
+** =======================================================
+** PATTERN MATCHING
+** =======================================================
+*/
+
+#define MAX_CAPT 9
+
+struct Capture {
+  int level;  /* total number of captures (finished or unfinished) */
+  char *src_end;  /* end ('\0') of source string */
+  struct {
+    char *init;
+    int len;  /* -1 signals unfinished capture */
+  } capture[MAX_CAPT];
+};
+
+
+#define ESC	'%'
+#define SPECIALS  "^$*?.([%-"
+
+
+static void push_captures (struct Capture *cap)
+{
+  int i;
+  for (i=0; i<cap->level; i++)
+    lua_pushlstring(cap->capture[i].init, cap->capture[i].len);
+}
+
+
+static int check_cap (int l, struct Capture *cap)
+{
+  l -= '1';
+  if (!(0 <= l && l < cap->level && cap->capture[l].len != -1))
+    lua_error("invalid capture index");
+  return l;
+}
+
+
+static int capture_to_close (struct Capture *cap)
+{
+  int level = cap->level;
+  for (level--; level>=0; level--)
+    if (cap->capture[level].len == -1) return level;
+  lua_error("invalid pattern capture");
+  return 0;  /* to avoid warnings */
+}
+
+
+static char *bracket_end (char *p)
+{
+  return (*p == 0) ? NULL : strchr((*p=='^') ? p+2 : p+1, ']');
+}
+
+
+static int matchclass (int c, int cl)
+{
+  int res;
+  switch (tolower(cl)) {
+    case 'a' : res = isalpha(c); break;
+    case 'c' : res = iscntrl(c); break;
+    case 'd' : res = isdigit(c); break;
+    case 'l' : res = islower(c); break;
+    case 'p' : res = ispunct(c); break;
+    case 's' : res = isspace(c); break;
+    case 'u' : res = isupper(c); break;
+    case 'w' : res = isalnum(c); break;
+    case 'z' : res = (c == '\0'); break;
+    default: return (cl == c);
+  }
+  return (islower((unsigned char)cl) ? res : !res);
+}
+
+
+int luaI_singlematch (int c, char *p, char **ep)
+{
+  switch (*p) {
+    case '.':  /* matches any char */
+      *ep = p+1;
+      return 1;
+    case '\0':  /* end of pattern; matches nothing */
+      *ep = p;
+      return 0;
+    case ESC:
+      if (*(++p) == '\0')
+        luaL_verror("incorrect pattern (ends with `%c')", ESC);
+      *ep = p+1;
+      return matchclass(c, (unsigned char)*p);
+    case '[': {
+      char *end = bracket_end(p+1);
+      int sig = *(p+1) == '^' ? (p++, 0) : 1;
+      if (end == NULL) lua_error("incorrect pattern (missing `]')");
+      *ep = end+1;
+      while (++p < end) {
+        if (*p == ESC) {
+          if (((p+1) < end) && matchclass(c, (unsigned char)*++p))
+            return sig;
+        }
+        else if ((*(p+1) == '-') && (p+2 < end)) {
+          p+=2;
+          if ((unsigned char)*(p-2) <= c && c <= (unsigned char)*p)
+            return sig;
+        }
+        else if ((unsigned char)*p == c) return sig;
+      }
+      return !sig;
+    }
+    default:
+      *ep = p+1;
+      return ((unsigned char)*p == c);
+  }
+}
+
+
+static char *matchbalance (char *s, int b, int e, struct Capture *cap)
+{
+  if (*s != b) return NULL;
+  else {
+    int cont = 1;
+    while (++s < cap->src_end) {
+      if (*s == e) {
+        if (--cont == 0) return s+1;
+      }
+      else if (*s == b) cont++;
+    }
+  }
+  return NULL;  /* string ends out of balance */
+}
+
+
+static char *matchitem (char *s, char *p, struct Capture *cap, char **ep)
+{
+  if (*p == ESC) {
+    p++;
+    if (isdigit((unsigned char)*p)) {  /* capture */
+      int l = check_cap(*p, cap);
+      int len = cap->capture[l].len;
+      *ep = p+1;
+      if (cap->src_end-s >= len && memcmp(cap->capture[l].init, s, len) == 0)
+        return s+len;
+      else return NULL;
+    }
+    else if (*p == 'b') {  /* balanced string */
+      p++;
+      if (*p == 0 || *(p+1) == 0)
+        lua_error("unbalanced pattern");
+      *ep = p+2;
+      return matchbalance(s, *p, *(p+1), cap);
+    }
+    else p--;  /* and go through */
+  }
+  /* "luaI_singlematch" sets "ep" (so must be called even when *s == 0) */
+  return (luaI_singlematch((unsigned char)*s, p, ep) && s<cap->src_end) ?
+                    s+1 : NULL;
+}
+
+
+static char *match (char *s, char *p, struct Capture *cap)
+{
+  init: /* using goto's to optimize tail recursion */
+  switch (*p) {
+    case '(': {  /* start capture */
+      char *res;
+      if (cap->level >= MAX_CAPT) lua_error("too many captures");
+      cap->capture[cap->level].init = s;
+      cap->capture[cap->level].len = -1;
+      cap->level++;
+      if ((res=match(s, p+1, cap)) == NULL)  /* match failed? */
+        cap->level--;  /* undo capture */
+      return res;
+    }
+    case ')': {  /* end capture */
+      int l = capture_to_close(cap);
+      char *res;
+      cap->capture[l].len = s - cap->capture[l].init;  /* close capture */
+      if ((res = match(s, p+1, cap)) == NULL)  /* match failed? */
+        cap->capture[l].len = -1;  /* undo capture */
+      return res;
+    }
+    case '\0': case '$':  /* (possibly) end of pattern */
+      if (*p == 0 || (*(p+1) == 0 && s == cap->src_end))
+        return s;
+      /* else go through */
+    default: {  /* it is a pattern item */
+      char *ep;  /* get what is next */
+      char *s1 = matchitem(s, p, cap, &ep);
+      switch (*ep) {
+        case '*': {  /* repetition */
+          char *res;
+          if (s1 && s1>s && ((res=match(s1, p, cap)) != NULL))
+            return res;
+          p=ep+1; goto init;  /* else return match(s, ep+1, cap); */
+        }
+        case '?': {  /* optional */
+          char *res;
+          if (s1 && ((res=match(s1, ep+1, cap)) != NULL))
+            return res;
+          p=ep+1; goto init;  /* else return match(s, ep+1, cap); */
+        }
+        case '-': {  /* repetition */
+          char *res;
+          if ((res = match(s, ep+1, cap)) != NULL)
+            return res;
+          else if (s1 && s1>s) {
+            s = s1;
+            goto init;  /* return match(s1, p, cap); */
+          }
+          else
+            return NULL;
+        }
+        default:
+          if (s1) { s=s1; p=ep; goto init; }  /* return match(s1, ep, cap); */
+          else return NULL;
+      }
+    }
+  }
+}
+
+
+static void str_find (void)
+{
+  long l;
+  char *s = luaL_check_lstr(1, &l);
+  char *p = luaL_check_string(2);
+  long init = posrelat(luaL_opt_number(3, 1), l) - 1;
+  struct Capture cap;
+  luaL_arg_check(0 <= init && init <= l, 3, "out of range");
+  if (lua_getparam(4) != LUA_NOOBJECT ||
+      strpbrk(p, SPECIALS) == NULL) {  /* no special characters? */
+    char *s2 = strstr(s+init, p);
+    if (s2) {
+      lua_pushnumber(s2-s+1);
+      lua_pushnumber(s2-s+strlen(p));
+      return;
+    }
+  }
+  else {
+    int anchor = (*p == '^') ? (p++, 1) : 0;
+    char *s1=s+init;
+    cap.src_end = s+l;
+    do {
+      char *res;
+      cap.level = 0;
+      if ((res=match(s1, p, &cap)) != NULL) {
+        lua_pushnumber(s1-s+1);  /* start */
+        lua_pushnumber(res-s);   /* end */
+        push_captures(&cap);
+        return;
+      }
+    } while (s1++<cap.src_end && !anchor);
+  }
+  lua_pushnil();  /* if arrives here, it didn't find */
+}
+
+
+static void add_s (lua_Object newp, struct Capture *cap)
+{
+  if (lua_isstring(newp)) {
+    char *news = lua_getstring(newp);
+    int l = lua_strlen(newp);
+    int i;
+    for (i=0; i<l; i++) {
+      if (news[i] != ESC)
+        luaL_addchar(news[i]);
+      else {
+        i++;  /* skip ESC */
+        if (!isdigit((unsigned char)news[i]))
+          luaL_addchar(news[i]);
+        else {
+          int level = check_cap(news[i], cap);
+          addnchar(cap->capture[level].init, cap->capture[level].len);
+        }
+      }
+    }
+  }
+  else {  /* is a function */
+    lua_Object res;
+    int status;
+    int oldbuff;
+    lua_beginblock();
+    push_captures(cap);
+    /* function may use buffer, so save it and create a new one */
+    oldbuff = luaL_newbuffer(0);
+    status = lua_callfunction(newp);
+    /* restore old buffer */
+    luaL_oldbuffer(oldbuff);
+    if (status != 0) {
+      lua_endblock();
+      lua_error(NULL);
+    }
+    res = lua_getresult(1);
+    if (lua_isstring(res))
+      addnchar(lua_getstring(res), lua_strlen(res));
+    lua_endblock();
+  }
+}
+
+
+static void str_gsub (void)
+{
+  long srcl;
+  char *src = luaL_check_lstr(1, &srcl);
+  char *p = luaL_check_string(2);
+  lua_Object newp = lua_getparam(3);
+  int max_s = (int)luaL_opt_number(4, srcl+1);
+  int anchor = (*p == '^') ? (p++, 1) : 0;
+  int n = 0;
+  struct Capture cap;
+  luaL_arg_check(lua_isstring(newp) || lua_isfunction(newp), 3,
+                 "string or function expected");
+  luaL_resetbuffer();
+  cap.src_end = src+srcl;
+  while (n < max_s) {
+    char *e;
+    cap.level = 0;
+    e = match(src, p, &cap);
+    if (e) {
+      n++;
+      add_s(newp, &cap);
+    }
+    if (e && e>src) /* non empty match? */
+      src = e;  /* skip it */
+    else if (src < cap.src_end)
+      luaL_addchar(*src++);
+    else break;
+    if (anchor) break;
+  }
+  addnchar(src, cap.src_end-src);
+  closeandpush();
+  lua_pushnumber(n);  /* number of substitutions */
+}
+
+
+static void luaI_addquoted (char *s)
+{
+  luaL_addchar('"');
+  for (; *s; s++) {
+    if (strchr("\"\\\n", *s))
+      luaL_addchar('\\');
+    luaL_addchar(*s);
+  }
+  luaL_addchar('"');
+}
+
+#define MAX_FORMAT 200
+
+static void str_format (void)
+{
+  int arg = 1;
+  char *strfrmt = luaL_check_string(arg);
+  struct Capture cap;
+  cap.src_end = strfrmt+strlen(strfrmt)+1;
+  luaL_resetbuffer();
+  while (*strfrmt) {
+    if (*strfrmt != '%')
+      luaL_addchar(*strfrmt++);
+    else if (*++strfrmt == '%')
+      luaL_addchar(*strfrmt++);  /* %% */
+    else { /* format item */
+      char form[MAX_FORMAT];      /* store the format ('%...') */
+      char *buff;
+      char *initf = strfrmt;
+      form[0] = '%';
+      cap.level = 0;
+      if (isdigit((unsigned char)initf[0]) && initf[1] == '$') {
+        arg = initf[0] - '0';
+        initf += 2;  /* skip the 'n$' */
+      }
+      arg++;
+      strfrmt = match(initf, "[-+ #0]*(%d*)%.?(%d*)", &cap);
+      if (cap.capture[0].len > 2 || cap.capture[1].len > 2)  /* < 100? */
+        lua_error("invalid format (width or precision too long)");
+      strncpy(form+1, initf, strfrmt-initf+1); /* +1 to include conversion */
+      form[strfrmt-initf+2] = 0;
+      buff = luaL_openspace(1000);  /* to store the formatted value */
+      switch (*strfrmt++) {
+        case 'q':
+          luaI_addquoted(luaL_check_string(arg));
+          continue;
+        case 's': {
+          char *s = luaL_check_string(arg);
+          buff = luaL_openspace(strlen(s));
+          sprintf(buff, form, s);
+          break;
+        }
+        case 'c':  case 'd':  case 'i':
+          sprintf(buff, form, (int)luaL_check_number(arg));
+          break;
+        case 'o':  case 'u':  case 'x':  case 'X':
+          sprintf(buff, form, (unsigned int)luaL_check_number(arg));
+          break;
+        case 'e':  case 'E': case 'f': case 'g': case 'G':
+          sprintf(buff, form, luaL_check_number(arg));
+          break;
+        default:  /* also treat cases 'pnLlh' */
+          lua_error("invalid option in `format'");
+      }
+      luaL_addsize(strlen(buff));
+    }
+  }
+  closeandpush();  /* push the result */
+}
+
+
+static 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 */
+{"strbyte", str_byte},
+{"format", str_format},
+{"strfind", str_find},
+{"gsub", str_gsub}
+};
+
+
+/*
+** Open string library
+*/
+void strlib_open (void)
+{
+  luaL_openlib(strlib, (sizeof(strlib)/sizeof(strlib[0])));
+}