no more explicit support for wide-chars; too much troble...

1 files changed, 113 insertions, 114 deletions

diff --git a/lbaselib.c b/lbaselib.c
index 73e5c8e6..52343fe5 100644
--- a/lbaselib.c
+++ b/lbaselib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbaselib.c,v 1.44 2001/10/17 21:12:57 roberto Exp $
+** $Id: lbaselib.c,v 1.45 2001/10/26 17:33:30 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
@@ -11,7 +11,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define LUA_PRIVATE
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -21,7 +20,7 @@
 
 
 static void aux_setn (lua_State *L, int t, int n) {
-  lua_pushliteral(L, l_s("n"));
+  lua_pushliteral(L, "n");
   lua_pushnumber(L, n);
   lua_settable(L, t);
 }
@@ -43,21 +42,21 @@ static int luaB__ALERT (lua_State *L) {
 */
 static int luaB__ERRORMESSAGE (lua_State *L) {
   luaL_check_rawtype(L, 1, LUA_TSTRING);
-  lua_getglobal(L, l_s(LUA_ALERT));
+  lua_getglobal(L, LUA_ALERT);
   if (lua_isfunction(L, -1)) {  /* avoid error loop if _ALERT is not defined */
     lua_Debug ar;
-    lua_pushliteral(L, l_s("error: "));
+    lua_pushliteral(L, "error: ");
     lua_pushvalue(L, 1);
     if (lua_getstack(L, 1, &ar)) {
-      lua_getinfo(L, l_s("Sl"), &ar);
+      lua_getinfo(L, "Sl", &ar);
       if (ar.source && ar.currentline > 0) {
-        l_char buff[100];
-        sprintf(buff, l_s("\n  <%.70s: line %d>"), ar.short_src, ar.currentline);
+        char buff[100];
+        sprintf(buff, "\n  <%.70s: line %d>", ar.short_src, ar.currentline);
         lua_pushstring(L, buff);
         lua_concat(L, 2);
       }
     }
-    lua_pushliteral(L, l_s("\n"));
+    lua_pushliteral(L, "\n");
     lua_concat(L, 3);
     lua_rawcall(L, 1, 0);
   }
@@ -74,20 +73,20 @@ static int luaB__ERRORMESSAGE (lua_State *L) {
 static int luaB_print (lua_State *L) {
   int n = lua_gettop(L);  /* number of arguments */
   int i;
-  lua_getglobal(L, l_s("tostring"));
+  lua_getglobal(L, "tostring");
   for (i=1; i<=n; i++) {
-    const l_char *s;
+    const char *s;
     lua_pushvalue(L, -1);  /* function to be called */
     lua_pushvalue(L, i);   /* value to print */
     lua_rawcall(L, 1, 1);
     s = lua_tostring(L, -1);  /* get result */
     if (s == NULL)
-      lua_error(L, l_s("`tostring' must return a string to `print'"));
-    if (i>1) fputs(l_s("\t"), stdout);
+      lua_error(L, "`tostring' must return a string to `print'");
+    if (i>1) fputs("\t", stdout);
     fputs(s, stdout);
     lua_pop(L, 1);  /* pop result */
   }
-  fputs(l_s("\n"), stdout);
+  fputs("\n", stdout);
   return 0;
 }
 
@@ -102,14 +101,14 @@ static int luaB_tonumber (lua_State *L) {
     }
   }
   else {
-    const l_char *s1 = luaL_check_string(L, 1);
-    l_char *s2;
+    const char *s1 = luaL_check_string(L, 1);
+    char *s2;
     unsigned long n;
-    luaL_arg_check(L, 2 <= base && base <= 36, 2, l_s("base out of range"));
+    luaL_arg_check(L, 2 <= base && base <= 36, 2, "base out of range");
     n = strtoul(s1, &s2, base);
     if (s1 != s2) {  /* at least one valid digit? */
-      while (isspace(uchar(*s2))) s2++;  /* skip trailing spaces */
-      if (*s2 == l_c('\0')) {  /* no invalid trailing characters? */
+      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
+      if (*s2 == '\0') {  /* no invalid trailing characters? */
         lua_pushnumber(L, n);
         return 1;
       }
@@ -143,14 +142,14 @@ static int gettag (lua_State *L, int narg) {
     case LUA_TNUMBER:
       return (int)(lua_tonumber(L, narg));
     case LUA_TSTRING: {
-      const l_char *name = lua_tostring(L, narg);
+      const char *name = lua_tostring(L, narg);
       int tag = lua_name2tag(L, name);
       if (tag == LUA_TNONE)
-        luaL_verror(L, l_s("'%.30s' is not a valid type name"), name);
+        luaL_verror(L, "'%.30s' is not a valid type name", name);
       return tag;
     }
     default:
-      luaL_argerror(L, narg, l_s("tag or type name expected"));
+      luaL_argerror(L, narg, "tag or type name expected");
       return 0;  /* to avoid warnings */
   }
 }
@@ -170,11 +169,11 @@ static int luaB_settype (lua_State *L) {
 }
 
 static int luaB_weakmode (lua_State *L) {
-  const l_char *mode = luaL_check_string(L, 2);
+  const char *mode = luaL_check_string(L, 2);
   luaL_check_rawtype(L, 1, LUA_TTABLE);
-  if (*mode == l_c('?')) {
-    l_char buff[3];
-    l_char *s = buff;
+  if (*mode == '?') {
+    char buff[3];
+    char *s = buff;
     int imode = lua_getweakmode(L, 1);
     if (imode & LUA_WEAK_KEY) *s++ = 'k';
     if (imode & LUA_WEAK_VALUE) *s++ = 'v';
@@ -184,8 +183,8 @@ static int luaB_weakmode (lua_State *L) {
   }
   else {
     int imode = 0;
-    if (strchr(mode, l_c('k'))) imode |= LUA_WEAK_KEY;
-    if (strchr(mode, l_c('v'))) imode |= LUA_WEAK_VALUE;
+    if (strchr(mode, 'k')) imode |= LUA_WEAK_KEY;
+    if (strchr(mode, 'v')) imode |= LUA_WEAK_VALUE;
     lua_pushvalue(L, 1);  /* push table */
     lua_setweakmode(L, imode);
     return 1;  /* return the table */
@@ -193,7 +192,7 @@ static int luaB_weakmode (lua_State *L) {
 }
 
 static int luaB_newtype (lua_State *L) {
-  const l_char *name = luaL_opt_string(L, 1, NULL);
+  const char *name = luaL_opt_string(L, 1, NULL);
   lua_pushnumber(L, lua_newtype(L, name, LUA_TTABLE));
   return 1;
 }
@@ -226,11 +225,11 @@ static int luaB_rawset (lua_State *L) {
 
 static int luaB_settagmethod (lua_State *L) {
   int tag = gettag(L, 1);
-  const l_char *event = luaL_check_string(L, 2);
+  const char *event = luaL_check_string(L, 2);
   luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3,
-                 l_s("function or nil expected"));
-  if (strcmp(event, l_s("gc")) == 0)
-    lua_error(L, l_s("cannot set `gc' tag method from Lua"));
+                 "function or nil expected");
+  if (strcmp(event, "gc") == 0)
+    lua_error(L, "cannot set `gc' tag method from Lua");
   lua_gettagmethod(L, tag, event);
   lua_pushvalue(L, 3);
   lua_settagmethod(L, tag, event);
@@ -240,9 +239,9 @@ static int luaB_settagmethod (lua_State *L) {
 
 static int luaB_gettagmethod (lua_State *L) {
   int tag = gettag(L, 1);
-  const l_char *event = luaL_check_string(L, 2);
-  if (strcmp(event, l_s("gc")) == 0)
-    lua_error(L, l_s("cannot get `gc' tag method from Lua"));
+  const char *event = luaL_check_string(L, 2);
+  if (strcmp(event, "gc") == 0)
+    lua_error(L, "cannot get `gc' tag method from Lua");
   lua_gettagmethod(L, tag, event);
   return 1;
 }
@@ -288,9 +287,9 @@ static int luaB_next (lua_State *L) {
 
 
 static int passresults (lua_State *L, int status, int oldtop) {
-  static const l_char *const errornames[] =
-    {l_s("ok"), l_s("run-time error"), l_s("file error"), l_s("syntax error"),
-     l_s("memory error"), l_s("error in error handling")};
+  static const char *const errornames[] =
+    {"ok", "run-time error", "file error", "syntax error",
+     "memory error", "error in error handling"};
   if (status == 0) {
     int nresults = lua_gettop(L) - oldtop;
     if (nresults > 0)
@@ -311,8 +310,8 @@ static int passresults (lua_State *L, int status, int oldtop) {
 static int luaB_dostring (lua_State *L) {
   int oldtop = lua_gettop(L);
   size_t l;
-  const l_char *s = luaL_check_lstr(L, 1, &l);
-  const l_char *chunkname = luaL_opt_string(L, 2, s);
+  const char *s = luaL_check_lstr(L, 1, &l);
+  const char *chunkname = luaL_opt_string(L, 2, s);
   return passresults(L, lua_dobuffer(L, s, l, chunkname), oldtop);
 }
 
@@ -320,36 +319,36 @@ static int luaB_dostring (lua_State *L) {
 static int luaB_loadstring (lua_State *L) {
   int oldtop = lua_gettop(L);
   size_t l;
-  const l_char *s = luaL_check_lstr(L, 1, &l);
-  const l_char *chunkname = luaL_opt_string(L, 2, s);
+  const char *s = luaL_check_lstr(L, 1, &l);
+  const char *chunkname = luaL_opt_string(L, 2, s);
   return passresults(L, lua_loadbuffer(L, s, l, chunkname), oldtop);
 }
 
 static int luaB_dofile (lua_State *L) {
   int oldtop = lua_gettop(L);
-  const l_char *fname = luaL_opt_string(L, 1, NULL);
+  const char *fname = luaL_opt_string(L, 1, NULL);
   return passresults(L, lua_dofile(L, fname), oldtop);
 }
 
 
 static int luaB_loadfile (lua_State *L) {
   int oldtop = lua_gettop(L);
-  const l_char *fname = luaL_opt_string(L, 1, NULL);
+  const char *fname = luaL_opt_string(L, 1, NULL);
   return passresults(L, lua_loadfile(L, fname), oldtop);
 }
 
 
 
-#define LUA_PATH        l_s("LUA_PATH")
+#define LUA_PATH        "LUA_PATH"
 
-#define LUA_PATH_SEP    l_s(";")
+#define LUA_PATH_SEP    ";"
 
 #ifndef LUA_PATH_DEFAULT
-#define LUA_PATH_DEFAULT        l_s("./")
+#define LUA_PATH_DEFAULT        "./"
 #endif
 
 static int luaB_require (lua_State *L) {
-  const l_char *path;
+  const char *path;
   luaL_check_string(L, 1);
   lua_settop(L, 1);
   lua_getglobal(L, LUA_PATH);  /* get path */
@@ -379,8 +378,8 @@ static int luaB_require (lua_State *L) {
       if (res == 0) break;  /* ok; file done */
       else if (res != LUA_ERRFILE)
         lua_error(L, NULL);  /* error running package; propagate it */
-      if (*(path+l) == l_c('\0'))  /* no more directories? */
-        luaL_verror(L, l_s("could not load package `%.20s' from path `%.200s'"),
+      if (*(path+l) == '\0')  /* no more directories? */
+        luaL_verror(L, "could not load package `%.20s' from path `%.200s'",
                     lua_tostring(L, 1), lua_tostring(L, 2));
       path += l+1;  /* try next directory */
     }
@@ -396,7 +395,7 @@ static int aux_unpack (lua_State *L, int arg) {
   int n, i;
   luaL_check_rawtype(L, arg, LUA_TTABLE);
   n = lua_getn(L, arg);
-  luaL_check_stack(L, n, l_s("table too big to unpack"));
+  luaL_check_stack(L, n, "table too big to unpack");
   for (i=1; i<=n; i++)  /* push arg[1...n] */
     lua_rawgeti(L, arg, i);
   return n;
@@ -410,15 +409,15 @@ static int luaB_unpack (lua_State *L) {
 
 static int luaB_call (lua_State *L) {
   int oldtop;
-  const l_char *options = luaL_opt_string(L, 3, l_s(""));
+  const char *options = luaL_opt_string(L, 3, "");
   int err = 0;  /* index of old error method */
   int status;
   int n;
   if (!lua_isnull(L, 4)) {  /* set new error method */
-    lua_getglobal(L, l_s(LUA_ERRORMESSAGE));
+    lua_getglobal(L, LUA_ERRORMESSAGE);
     err = lua_gettop(L);  /* get index */
     lua_pushvalue(L, 4);
-    lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
+    lua_setglobal(L, LUA_ERRORMESSAGE);
   }
   oldtop = lua_gettop(L);  /* top before function-call preparation */
   /* push function */
@@ -427,23 +426,23 @@ static int luaB_call (lua_State *L) {
   status = lua_call(L, n, LUA_MULTRET);
   if (err != 0) {  /* restore old error method */
     lua_pushvalue(L, err);
-    lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
+    lua_setglobal(L, LUA_ERRORMESSAGE);
   }
   if (status != 0) {  /* error in call? */
-    if (strchr(options, l_c('x')))
+    if (strchr(options, 'x'))
       lua_pushnil(L);  /* return nil to signal the error */
     else
       lua_error(L, NULL);  /* propagate error without additional messages */
     return 1;
   }
-  if (strchr(options, l_c('p')))  /* pack results? */
-    lua_error(L, l_s("obsolete option `p' in `call'"));
+  if (strchr(options, 'p'))  /* pack results? */
+    lua_error(L, "obsolete option `p' in `call'");
   return lua_gettop(L) - oldtop;  /* results are already on the stack */
 }
 
 
 static int luaB_tostring (lua_State *L) {
-  l_char buff[64];
+  char buff[64];
   switch (lua_rawtag(L, 1)) {
     case LUA_TNUMBER:
       lua_pushstring(L, lua_tostring(L, 1));
@@ -452,25 +451,25 @@ static int luaB_tostring (lua_State *L) {
       lua_pushvalue(L, 1);
       return 1;
     case LUA_TTABLE:
-      sprintf(buff, l_s("%.40s: %p"), lua_type(L, 1), lua_topointer(L, 1));
+      sprintf(buff, "%.40s: %p", lua_type(L, 1), lua_topointer(L, 1));
       break;
     case LUA_TFUNCTION:
-      sprintf(buff, l_s("function: %p"), lua_topointer(L, 1));
+      sprintf(buff, "function: %p", lua_topointer(L, 1));
       break;
     case LUA_TUSERDATA: {
-      const l_char *t = lua_type(L, 1);
-      if (strcmp(t, l_s("userdata")) == 0)
-        sprintf(buff, l_s("userdata(%d): %p"), lua_tag(L, 1),
+      const char *t = lua_type(L, 1);
+      if (strcmp(t, "userdata") == 0)
+        sprintf(buff, "userdata(%d): %p", lua_tag(L, 1),
                 lua_touserdata(L, 1));
       else
-        sprintf(buff, l_s("%.40s: %p"), t, lua_touserdata(L, 1));
+        sprintf(buff, "%.40s: %p", t, lua_touserdata(L, 1));
       break;
     }
     case LUA_TNIL:
-      lua_pushliteral(L, l_s("nil"));
+      lua_pushliteral(L, "nil");
       return 1;
     default:
-      luaL_argerror(L, 1, l_s("value expected"));
+      luaL_argerror(L, 1, "value expected");
   }
   lua_pushstring(L, buff);
   return 1;
@@ -516,8 +515,8 @@ static int luaB_foreach (lua_State *L) {
 static int luaB_assert (lua_State *L) {
   luaL_check_any(L, 1);
   if (lua_isnil(L, 1))
-    luaL_verror(L, l_s("assertion failed!  %.90s"),
-                   luaL_opt_string(L, 2, l_s("")));
+    luaL_verror(L, "assertion failed!  %.90s",
+                   luaL_opt_string(L, 2, ""));
   lua_settop(L, 1);
   return 1;
 }
@@ -635,12 +634,12 @@ static void auxsort (lua_State *L, int l, int u) {
     for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
       /* repeat ++i until a[i] >= P */
       while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
-        if (i>u) lua_error(L, l_s("invalid order function for sorting"));
+        if (i>u) lua_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[i] */
       }
       /* repeat --j until a[j] <= P */
       while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
-        if (j<l) lua_error(L, l_s("invalid order function for sorting"));
+        if (j<l) lua_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[j] */
       }
       if (j<i) {
@@ -680,57 +679,57 @@ static int luaB_sort (lua_State *L) {
 
 
 static const luaL_reg base_funcs[] = {
-  {l_s(LUA_ALERT), luaB__ALERT},
-  {l_s(LUA_ERRORMESSAGE), luaB__ERRORMESSAGE},
-  {l_s("call"), luaB_call},
-  {l_s("collectgarbage"), luaB_collectgarbage},
-  {l_s("dofile"), luaB_dofile},
-  {l_s("dostring"), luaB_dostring},
-  {l_s("error"), luaB_error},
-  {l_s("foreach"), luaB_foreach},
-  {l_s("foreachi"), luaB_foreachi},
-  {l_s("gcinfo"), luaB_gcinfo},
-  {l_s("getglobal"), luaB_getglobal},
-  {l_s("gettagmethod"), luaB_gettagmethod},
-  {l_s("globals"), luaB_globals},
-  {l_s("loadfile"), luaB_loadfile},
-  {l_s("loadstring"), luaB_loadstring},
-  {l_s("newtype"), luaB_newtype},
-  {l_s("newtag"), luaB_newtype},  /* for compatibility 4.0 */
-  {l_s("next"), luaB_next},
-  {l_s("print"), luaB_print},
-  {l_s("rawget"), luaB_rawget},
-  {l_s("rawset"), luaB_rawset},
-  {l_s("rawgettable"), luaB_rawget},  /* for compatibility 3.2 */
-  {l_s("rawsettable"), luaB_rawset},  /* for compatibility 3.2 */
-  {l_s("rawtype"), luaB_rawtype},
-  {l_s("setglobal"), luaB_setglobal},
-  {l_s("settag"), luaB_settype},  /* for compatibility 4.0 */
-  {l_s("settype"), luaB_settype},
-  {l_s("settagmethod"), luaB_settagmethod},
-  {l_s("tag"), luaB_tag},
-  {l_s("tonumber"), luaB_tonumber},
-  {l_s("tostring"), luaB_tostring},
-  {l_s("type"), luaB_type},
-  {l_s("assert"), luaB_assert},
-  {l_s("getn"), luaB_getn},
-  {l_s("sort"), luaB_sort},
-  {l_s("tinsert"), luaB_tinsert},
-  {l_s("tremove"), luaB_tremove},
-  {l_s("unpack"), luaB_unpack},
-  {l_s("weakmode"), luaB_weakmode}
+  {LUA_ALERT, luaB__ALERT},
+  {LUA_ERRORMESSAGE, luaB__ERRORMESSAGE},
+  {"call", luaB_call},
+  {"collectgarbage", luaB_collectgarbage},
+  {"dofile", luaB_dofile},
+  {"dostring", luaB_dostring},
+  {"error", luaB_error},
+  {"foreach", luaB_foreach},
+  {"foreachi", luaB_foreachi},
+  {"gcinfo", luaB_gcinfo},
+  {"getglobal", luaB_getglobal},
+  {"gettagmethod", luaB_gettagmethod},
+  {"globals", luaB_globals},
+  {"loadfile", luaB_loadfile},
+  {"loadstring", luaB_loadstring},
+  {"newtype", luaB_newtype},
+  {"newtag", luaB_newtype},  /* for compatibility 4.0 */
+  {"next", luaB_next},
+  {"print", luaB_print},
+  {"rawget", luaB_rawget},
+  {"rawset", luaB_rawset},
+  {"rawgettable", luaB_rawget},  /* for compatibility 3.2 */
+  {"rawsettable", luaB_rawset},  /* for compatibility 3.2 */
+  {"rawtype", luaB_rawtype},
+  {"setglobal", luaB_setglobal},
+  {"settag", luaB_settype},  /* for compatibility 4.0 */
+  {"settype", luaB_settype},
+  {"settagmethod", luaB_settagmethod},
+  {"tag", luaB_tag},
+  {"tonumber", luaB_tonumber},
+  {"tostring", luaB_tostring},
+  {"type", luaB_type},
+  {"assert", luaB_assert},
+  {"getn", luaB_getn},
+  {"sort", luaB_sort},
+  {"tinsert", luaB_tinsert},
+  {"tremove", luaB_tremove},
+  {"unpack", luaB_unpack},
+  {"weakmode", luaB_weakmode}
 };
 
 
 
 LUALIB_API int lua_baselibopen (lua_State *L) {
   luaL_openl(L, base_funcs);
-  lua_pushliteral(L, l_s(LUA_VERSION));
-  lua_setglobal(L, l_s("_VERSION"));
+  lua_pushliteral(L, LUA_VERSION);
+  lua_setglobal(L, "_VERSION");
   /* `require' needs an empty table as upvalue */
   lua_newtable(L);
   lua_pushcclosure(L, luaB_require, 1);
-  lua_setglobal(L, l_s("require"));
+  lua_setglobal(L, "require");
   return 0;
 }