From 39b79783297bee79db9853b63d199e120a009a8f Mon Sep 17 00:00:00 2001
From: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date: Fri, 23 Feb 2001 14:17:25 -0300
Subject: first (big) step to support wide chars
---
lapi.c | 50 ++++++------
lauxlib.c | 43 +++++-----
lauxlib.h | 30 +++----
lbaselib.c | 194 ++++++++++++++++++++++----------------------
lcode.c | 16 ++--
lcode.h | 4 +-
ldblib.c | 64 +++++++--------
ldebug.c | 80 +++++++++----------
ldebug.h | 6 +-
ldo.c | 44 +++++-----
ldo.h | 4 +-
lfunc.c | 4 +-
lfunc.h | 4 +-
lgc.c | 4 +-
liolib.c | 252 ++++++++++++++++++++++++++++-----------------------------
llex.c | 230 ++++++++++++++++++++++++++--------------------------
llex.h | 12 +--
llimits.h | 22 +++--
lmathlib.c | 58 +++++++-------
lmem.c | 6 +-
lmem.h | 4 +-
lobject.c | 42 +++++-----
lobject.h | 14 ++--
lparser.c | 184 +++++++++++++++++++++---------------------
lstate.c | 4 +-
lstate.h | 8 +-
lstring.c | 6 +-
lstring.h | 10 +--
lstrlib.c | 254 +++++++++++++++++++++++++++++-----------------------------
ltable.c | 12 +--
ltests.c | 266 ++++++++++++++++++++++++++++++-------------------------------
ltm.c | 42 +++++-----
ltm.h | 8 +-
lua.c | 106 ++++++++++++------------
lua.h | 41 +++++-----
luadebug.h | 20 ++---
lualib.h | 12 ++-
lundump.c | 50 ++++++------
lundump.h | 8 +-
lvm.c | 54 ++++++-------
40 files changed, 1151 insertions(+), 1121 deletions(-)
diff --git a/lapi.c b/lapi.c
index db6d6a91..ab8c0ae6 100644
--- a/lapi.c
+++ b/lapi.c
@@ -1,5 +1,5 @@
/*
-** $Id: lapi.c,v 1.131 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lapi.c,v 1.132 2001/02/22 18:59:59 roberto Exp roberto $
** Lua API
** See Copyright Notice in lua.h
*/
@@ -22,8 +22,8 @@
#include "lvm.h"
-const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
- "$Authors: " LUA_AUTHORS " $";
+const l_char lua_ident[] = l_s("$Lua: ") l_s(LUA_VERSION) l_s(" ")
+ l_s(LUA_COPYRIGHT) l_s(" $\n") l_s("$Authors: ") l_s(LUA_AUTHORS) l_s(" $");
@@ -150,21 +150,21 @@ LUA_API int lua_type (lua_State *L, int index) {
}
-LUA_API const char *lua_typename (lua_State *L, int t) {
- const char *s;
+LUA_API const l_char *lua_typename (lua_State *L, int t) {
+ const l_char *s;
LUA_LOCK(L);
- s = (t == LUA_TNONE) ? "no value" : basictypename(G(L), t);
+ s = (t == LUA_TNONE) ? l_s("no value") : basictypename(G(L), t);
LUA_UNLOCK(L);
return s;
}
-LUA_API const char *lua_xtype (lua_State *L, int index) {
+LUA_API const l_char *lua_xtype (lua_State *L, int index) {
StkId o;
- const char *type;
+ const l_char *type;
LUA_LOCK(L);
o = luaA_indexAcceptable(L, index);
- type = (o == NULL) ? "no value" : luaT_typename(G(L), o);
+ type = (o == NULL) ? l_s("no value") : luaT_typename(G(L), o);
LUA_UNLOCK(L);
return type;
}
@@ -242,9 +242,9 @@ LUA_API lua_Number lua_tonumber (lua_State *L, int index) {
return n;
}
-LUA_API const char *lua_tostring (lua_State *L, int index) {
+LUA_API const l_char *lua_tostring (lua_State *L, int index) {
StkId o;
- const char *s;
+ const l_char *s;
LUA_LOCK(L);
o = luaA_indexAcceptable(L, index);
s = (o == NULL || tostring(L, o)) ? NULL : svalue(o);
@@ -329,7 +329,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
}
-LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
+LUA_API void lua_pushlstring (lua_State *L, const l_char *s, size_t len) {
LUA_LOCK(L);
setsvalue(L->top, luaS_newlstr(L, s, len));
api_incr_top(L);
@@ -337,7 +337,7 @@ LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
}
-LUA_API void lua_pushstring (lua_State *L, const char *s) {
+LUA_API void lua_pushstring (lua_State *L, const l_char *s) {
if (s == NULL)
lua_pushnil(L);
else
@@ -369,7 +369,7 @@ LUA_API int lua_pushuserdata (lua_State *L, void *u) {
*/
-LUA_API void lua_getglobal (lua_State *L, const char *name) {
+LUA_API void lua_getglobal (lua_State *L, const l_char *name) {
LUA_LOCK(L);
luaV_getglobal(L, luaS_new(L, name), L->top);
api_incr_top(L);
@@ -450,7 +450,7 @@ LUA_API void lua_newtable (lua_State *L) {
*/
-LUA_API void lua_setglobal (lua_State *L, const char *name) {
+LUA_API void lua_setglobal (lua_State *L, const l_char *name) {
LUA_LOCK(L);
api_checknelems(L, 1);
luaV_setglobal(L, luaS_new(L, name), L->top - 1);
@@ -518,7 +518,7 @@ LUA_API int lua_ref (lua_State *L, int lock) {
}
else { /* no more free places */
luaM_growvector(L, G(L)->refArray, G(L)->nref, G(L)->sizeref, struct Ref,
- MAX_INT, "reference table overflow");
+ MAX_INT, l_s("reference table overflow"));
ref = G(L)->nref++;
}
setobj(&G(L)->refArray[ref].o, L->top-1);
@@ -582,22 +582,22 @@ LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) {
** miscellaneous functions
*/
-LUA_API int lua_newtype (lua_State *L, const char *name, int basictype) {
+LUA_API int lua_newtype (lua_State *L, const l_char *name, int basictype) {
int tag;
LUA_LOCK(L);
if (basictype != LUA_TNONE &&
basictype != LUA_TTABLE &&
basictype != LUA_TUSERDATA)
- luaO_verror(L, "invalid basic type (%d) for new type", basictype);
+ luaO_verror(L, l_s("invalid basic type (%d) for new type"), basictype);
tag = luaT_newtag(L, name, basictype);
if (tag == LUA_TNONE)
- luaO_verror(L, "type name '%.30s' already exists", name);
+ luaO_verror(L, l_s("type name '%.30s' already exists"), name);
LUA_UNLOCK(L);
return tag;
}
-LUA_API int lua_type2tag (lua_State *L, const char *name) {
+LUA_API int lua_type2tag (lua_State *L, const l_char *name) {
int tag;
const TObject *v;
LUA_LOCK(L);
@@ -618,10 +618,10 @@ LUA_API void lua_settag (lua_State *L, int tag) {
LUA_LOCK(L);
api_checknelems(L, 1);
if (tag < 0 || tag >= G(L)->ntag)
- luaO_verror(L, "%d is not a valid tag", tag);
+ luaO_verror(L, l_s("%d is not a valid tag"), tag);
basictype = G(L)->TMtable[tag].basictype;
if (basictype != LUA_TNONE && basictype != ttype(L->top-1))
- luaO_verror(L, "tag %d can only be used for type '%.20s'", tag,
+ luaO_verror(L, l_s("tag %d can only be used for type '%.20s'"), tag,
basictypename(G(L), basictype));
switch (ttype(L->top-1)) {
case LUA_TTABLE:
@@ -631,14 +631,14 @@ LUA_API void lua_settag (lua_State *L, int tag) {
tsvalue(L->top-1)->u.d.tag = tag;
break;
default:
- luaO_verror(L, "cannot change the tag of a %.20s",
+ luaO_verror(L, l_s("cannot change the tag of a %.20s"),
luaT_typename(G(L), L->top-1));
}
LUA_UNLOCK(L);
}
-LUA_API void lua_error (lua_State *L, const char *s) {
+LUA_API void lua_error (lua_State *L, const l_char *s) {
LUA_LOCK(L);
luaD_error(L, s);
LUA_UNLOCK(L);
@@ -685,7 +685,7 @@ LUA_API int lua_getn (lua_State *L, int index) {
int n;
LUA_LOCK(L);
h = hvalue(luaA_index(L, index));
- value = luaH_getstr(h, luaS_newliteral(L, "n")); /* = h.n */
+ value = luaH_getstr(h, luaS_newliteral(L, l_s("n"))); /* = h.n */
if (ttype(value) == LUA_TNUMBER)
n = (int)nvalue(value);
else {
diff --git a/lauxlib.c b/lauxlib.c
index d36424d2..5e9f4e89 100644
--- a/lauxlib.c
+++ b/lauxlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.c,v 1.46 2001/02/02 19:02:40 roberto Exp roberto $
+** $Id: lauxlib.c,v 1.47 2001/02/14 17:04:11 roberto Exp roberto $
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/
@@ -18,10 +18,11 @@
#include "lauxlib.h"
#include "luadebug.h"
+#include "lualib.h"
-LUALIB_API int luaL_findstring (const char *name, const char *const list[]) {
+LUALIB_API int luaL_findstring (const l_char *name, const l_char *const list[]) {
int i;
for (i=0; list[i]; i++)
if (strcmp(list[i], name) == 0)
@@ -29,20 +30,20 @@ LUALIB_API int luaL_findstring (const char *name, const char *const list[]) {
return -1; /* name not found */
}
-LUALIB_API void luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API void luaL_argerror (lua_State *L, int narg, const l_char *extramsg) {
lua_Debug ar;
lua_getstack(L, 0, &ar);
- lua_getinfo(L, "n", &ar);
+ lua_getinfo(L, l_s("n"), &ar);
if (ar.name == NULL)
- ar.name = "?";
- luaL_verror(L, "bad argument #%d to `%.50s' (%.100s)",
+ ar.name = l_s("?");
+ luaL_verror(L, l_s("bad argument #%d to `%.50s' (%.100s)"),
narg, ar.name, extramsg);
}
-static void type_error (lua_State *L, int narg, const char *tname) {
- char buff[80];
- sprintf(buff, "%.25s expected, got %.25s", tname, lua_xtype(L, narg));
+static void type_error (lua_State *L, int narg, const l_char *tname) {
+ l_char buff[80];
+ sprintf(buff, l_s("%.25s expected, got %.25s"), tname, lua_xtype(L, narg));
luaL_argerror(L, narg, buff);
}
@@ -52,9 +53,9 @@ static void tag_error (lua_State *L, int narg, int tag) {
}
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const l_char *mes) {
if (space > lua_stackspace(L))
- luaL_verror(L, "stack overflow (%.30s)", mes);
+ luaL_verror(L, l_s("stack overflow (%.30s)"), mes);
}
@@ -66,27 +67,27 @@ LUALIB_API void luaL_checktype(lua_State *L, int narg, int t) {
LUALIB_API void luaL_checkany (lua_State *L, int narg) {
if (lua_type(L, narg) == LUA_TNONE)
- luaL_argerror(L, narg, "value expected");
+ luaL_argerror(L, narg, l_s("value expected"));
}
LUALIB_API void *luaL_check_userdata (lua_State *L, int narg,
- const char *name) {
+ const l_char *name) {
if (strcmp(lua_xtype(L, narg), name) != 0)
type_error(L, narg, name);
return lua_touserdata(L, narg);
}
-LUALIB_API const char *luaL_check_lstr (lua_State *L, int narg, size_t *len) {
- const char *s = lua_tostring(L, narg);
+LUALIB_API const l_char *luaL_check_lstr (lua_State *L, int narg, size_t *len) {
+ const l_char *s = lua_tostring(L, narg);
if (!s) tag_error(L, narg, LUA_TSTRING);
if (len) *len = lua_strlen(L, narg);
return s;
}
-LUALIB_API const char *luaL_opt_lstr (lua_State *L, int narg, const char *def, size_t *len) {
+LUALIB_API const l_char *luaL_opt_lstr (lua_State *L, int narg, const l_char *def, size_t *len) {
if (lua_isnull(L, narg)) {
if (len)
*len = (def ? strlen(def) : 0);
@@ -117,8 +118,8 @@ LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n) {
}
-LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...) {
- char buff[500];
+LUALIB_API void luaL_verror (lua_State *L, const l_char *fmt, ...) {
+ l_char buff[500];
va_list argp;
va_start(argp, fmt);
vsprintf(buff, fmt, argp);
@@ -172,20 +173,20 @@ static void adjuststack (luaL_Buffer *B) {
}
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
+LUALIB_API l_char *luaL_prepbuffer (luaL_Buffer *B) {
if (emptybuffer(B))
adjuststack(B);
return B->buffer;
}
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const l_char *s, size_t l) {
while (l--)
luaL_putchar(B, *s++);
}
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const l_char *s) {
luaL_addlstring(B, s, strlen(s));
}
diff --git a/lauxlib.h b/lauxlib.h
index f5cffa79..ffaca461 100644
--- a/lauxlib.h
+++ b/lauxlib.h
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.h,v 1.32 2001/01/25 16:45:36 roberto Exp roberto $
+** $Id: lauxlib.h,v 1.33 2001/02/02 19:02:40 roberto Exp roberto $
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/
@@ -21,25 +21,25 @@
typedef struct luaL_reg {
- const char *name;
+ const l_char *name;
lua_CFunction func;
} luaL_reg;
LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n);
-LUALIB_API void luaL_argerror (lua_State *L, int numarg, const char *extramsg);
-LUALIB_API const char *luaL_check_lstr (lua_State *L, int numArg, size_t *len);
-LUALIB_API const char *luaL_opt_lstr (lua_State *L, int numArg, const char *def, size_t *len);
+LUALIB_API void luaL_argerror (lua_State *L, int numarg, const l_char *extramsg);
+LUALIB_API const l_char *luaL_check_lstr (lua_State *L, int numArg, size_t *len);
+LUALIB_API const l_char *luaL_opt_lstr (lua_State *L, int numArg, const l_char *def, size_t *len);
LUALIB_API lua_Number luaL_check_number (lua_State *L, int numArg);
LUALIB_API lua_Number luaL_opt_number (lua_State *L, int nArg, lua_Number def);
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg);
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const l_char *msg);
LUALIB_API void luaL_checktype (lua_State *L, int narg, int t);
LUALIB_API void luaL_checkany (lua_State *L, int narg);
-LUALIB_API void *luaL_check_userdata (lua_State *L, int narg, const char *name);
+LUALIB_API void *luaL_check_userdata (lua_State *L, int narg, const l_char *name);
-LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...);
-LUALIB_API int luaL_findstring (const char *name, const char *const list[]);
+LUALIB_API void luaL_verror (lua_State *L, const l_char *fmt, ...);
+LUALIB_API int luaL_findstring (const l_char *name, const l_char *const list[]);
@@ -73,22 +73,22 @@ LUALIB_API int luaL_findstring (const char *name, const char *const list[]);
typedef struct luaL_Buffer {
- char *p; /* current position in buffer */
+ l_char *p; /* current position in buffer */
int level;
lua_State *L;
- char buffer[LUAL_BUFFERSIZE];
+ l_char buffer[LUAL_BUFFERSIZE];
} luaL_Buffer;
#define luaL_putchar(B,c) \
((void)((B)->p < &(B)->buffer[LUAL_BUFFERSIZE] || luaL_prepbuffer(B)), \
- (*(B)->p++ = (char)(c)))
+ (*(B)->p++ = (l_char)(c)))
#define luaL_addsize(B,n) ((B)->p += (n))
LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B);
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s);
+LUALIB_API l_char *luaL_prepbuffer (luaL_Buffer *B);
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const l_char *s, size_t l);
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const l_char *s);
LUALIB_API void luaL_addvalue (luaL_Buffer *B);
LUALIB_API void luaL_pushresult (luaL_Buffer *B);
diff --git a/lbaselib.c b/lbaselib.c
index 6ec951ca..2089d509 100644
--- a/lbaselib.c
+++ b/lbaselib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lbaselib.c,v 1.25 2001/02/22 17:15:18 roberto Exp roberto $
+** $Id: lbaselib.c,v 1.26 2001/02/22 18:59:59 roberto Exp roberto $
** Basic library
** See Copyright Notice in lua.h
*/
@@ -35,21 +35,21 @@ static int luaB__ALERT (lua_State *L) {
*/
static int luaB__ERRORMESSAGE (lua_State *L) {
luaL_checktype(L, 1, LUA_TSTRING);
- lua_getglobal(L, LUA_ALERT);
+ lua_getglobal(L, l_s(LUA_ALERT));
if (lua_isfunction(L, -1)) { /* avoid error loop if _ALERT is not defined */
lua_Debug ar;
- lua_pushliteral(L, "error: ");
+ lua_pushliteral(L, l_s("error: "));
lua_pushvalue(L, 1);
if (lua_getstack(L, 1, &ar)) {
- lua_getinfo(L, "Sl", &ar);
+ lua_getinfo(L, l_s("Sl"), &ar);
if (ar.source && ar.currentline > 0) {
- char buff[100];
- sprintf(buff, "\n <%.70s: line %d>", ar.short_src, ar.currentline);
+ l_char buff[100];
+ sprintf(buff, l_s("\n <%.70s: line %d>"), ar.short_src, ar.currentline);
lua_pushstring(L, buff);
lua_concat(L, 2);
}
}
- lua_pushliteral(L, "\n");
+ lua_pushliteral(L, l_s("\n"));
lua_concat(L, 3);
lua_rawcall(L, 1, 0);
}
@@ -66,20 +66,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, "tostring");
+ lua_getglobal(L, l_s("tostring"));
for (i=1; i<=n; i++) {
- const char *s;
+ const l_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, "`tostring' must return a string to `print'");
- if (i>1) fputs("\t", stdout);
+ lua_error(L, l_s("`tostring' must return a string to `print'"));
+ if (i>1) fputs(l_s("\t"), stdout);
fputs(s, stdout);
lua_pop(L, 1); /* pop result */
}
- fputs("\n", stdout);
+ fputs(l_s("\n"), stdout);
return 0;
}
@@ -94,14 +94,14 @@ static int luaB_tonumber (lua_State *L) {
}
}
else {
- const char *s1 = luaL_check_string(L, 1);
- char *s2;
+ const l_char *s1 = luaL_check_string(L, 1);
+ l_char *s2;
unsigned long n;
- luaL_arg_check(L, 2 <= base && base <= 36, 2, "base out of range");
+ luaL_arg_check(L, 2 <= base && base <= 36, 2, l_s("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 == '\0') { /* no invalid trailing characters? */
+ if (*s2 == l_c('\0')) { /* no invalid trailing characters? */
lua_pushnumber(L, n);
return 1;
}
@@ -135,14 +135,14 @@ static int gettag (lua_State *L, int narg) {
case LUA_TNUMBER:
return (int)lua_tonumber(L, narg);
case LUA_TSTRING: {
- const char *name = lua_tostring(L, narg);
+ const l_char *name = lua_tostring(L, narg);
int tag = lua_type2tag(L, name);
if (tag == LUA_TNONE)
- luaL_verror(L, "'%.30s' is not a valid type name", name);
+ luaL_verror(L, l_s("'%.30s' is not a valid type name"), name);
return tag;
}
default:
- luaL_argerror(L, narg, "tag or type name expected");
+ luaL_argerror(L, narg, l_s("tag or type name expected"));
return 0; /* to avoid warnings */
}
}
@@ -162,7 +162,7 @@ static int luaB_settag (lua_State *L) {
}
static int luaB_newtype (lua_State *L) {
- const char *name = luaL_opt_string(L, 1, NULL);
+ const l_char *name = luaL_opt_string(L, 1, NULL);
lua_pushnumber(L, lua_newtype(L, name, LUA_TTABLE));
return 1;
}
@@ -199,11 +199,11 @@ static int luaB_rawset (lua_State *L) {
static int luaB_settagmethod (lua_State *L) {
int tag = gettag(L, 1);
- const char *event = luaL_check_string(L, 2);
+ const l_char *event = luaL_check_string(L, 2);
luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3,
- "function or nil expected");
- if (strcmp(event, "gc") == 0)
- lua_error(L, "deprecated use: cannot set the `gc' tag method from Lua");
+ l_s("function or nil expected"));
+ if (strcmp(event, l_s("gc")) == 0)
+ lua_error(L, l_s("deprecated use: cannot set the `gc' tag method from Lua"));
lua_gettagmethod(L, tag, event);
lua_pushvalue(L, 3);
lua_settagmethod(L, tag, event);
@@ -213,9 +213,9 @@ static int luaB_settagmethod (lua_State *L) {
static int luaB_gettagmethod (lua_State *L) {
int tag = gettag(L, 1);
- const char *event = luaL_check_string(L, 2);
- if (strcmp(event, "gc") == 0)
- lua_error(L, "deprecated use: cannot get the `gc' tag method from Lua");
+ const l_char *event = luaL_check_string(L, 2);
+ if (strcmp(event, l_s("gc")) == 0)
+ lua_error(L, l_s("deprecated use: cannot get the `gc' tag method from Lua"));
lua_gettagmethod(L, tag, event);
return 1;
}
@@ -261,9 +261,9 @@ static int luaB_next (lua_State *L) {
static int passresults (lua_State *L, int status, int oldtop) {
- static const char *const errornames[] =
- {"ok", "run-time error", "file error", "syntax error",
- "memory error", "error in error handling"};
+ 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")};
if (status == 0) {
int nresults = lua_gettop(L) - oldtop;
if (nresults > 0)
@@ -283,59 +283,59 @@ 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 char *s = luaL_check_lstr(L, 1, &l);
- const char *chunkname = luaL_opt_string(L, 2, s);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *chunkname = luaL_opt_string(L, 2, s);
return passresults(L, lua_dobuffer(L, s, l, chunkname), oldtop);
}
static int luaB_dofile (lua_State *L) {
int oldtop = lua_gettop(L);
- const char *fname = luaL_opt_string(L, 1, NULL);
+ const l_char *fname = luaL_opt_string(L, 1, NULL);
return passresults(L, lua_dofile(L, fname), oldtop);
}
static int luaB_call (lua_State *L) {
int oldtop;
- const char *options = luaL_opt_string(L, 3, "");
+ const l_char *options = luaL_opt_string(L, 3, l_s(""));
int err = 0; /* index of old error method */
int i, status;
int n;
luaL_checktype(L, 2, LUA_TTABLE);
n = lua_getn(L, 2);
if (!lua_isnull(L, 4)) { /* set new error method */
- lua_getglobal(L, LUA_ERRORMESSAGE);
+ lua_getglobal(L, l_s(LUA_ERRORMESSAGE));
err = lua_gettop(L); /* get index */
lua_pushvalue(L, 4);
- lua_setglobal(L, LUA_ERRORMESSAGE);
+ lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
}
oldtop = lua_gettop(L); /* top before function-call preparation */
/* push function */
lua_pushvalue(L, 1);
- luaL_checkstack(L, n, "too many arguments");
+ luaL_checkstack(L, n, l_s("too many arguments"));
for (i=0; i<n; i++) /* push arg[1...n] */
lua_rawgeti(L, 2, i+1);
status = lua_call(L, n, LUA_MULTRET);
if (err != 0) { /* restore old error method */
lua_pushvalue(L, err);
- lua_setglobal(L, LUA_ERRORMESSAGE);
+ lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
}
if (status != 0) { /* error in call? */
- if (strchr(options, 'x'))
+ if (strchr(options, l_c('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, 'p')) /* pack results? */
- lua_error(L, "deprecated option `p' in `call'");
+ if (strchr(options, l_c('p'))) /* pack results? */
+ lua_error(L, l_s("deprecated option `p' in `call'"));
return lua_gettop(L) - oldtop; /* results are already on the stack */
}
static int luaB_tostring (lua_State *L) {
- char buff[64];
+ l_char buff[64];
switch (lua_type(L, 1)) {
case LUA_TNUMBER:
lua_pushstring(L, lua_tostring(L, 1));
@@ -344,24 +344,24 @@ static int luaB_tostring (lua_State *L) {
lua_pushvalue(L, 1);
return 1;
case LUA_TTABLE:
- sprintf(buff, "%.40s: %p", lua_xtype(L, 1), lua_topointer(L, 1));
+ sprintf(buff, l_s("%.40s: %p"), lua_xtype(L, 1), lua_topointer(L, 1));
break;
case LUA_TFUNCTION:
- sprintf(buff, "function: %p", lua_topointer(L, 1));
+ sprintf(buff, l_s("function: %p"), lua_topointer(L, 1));
break;
case LUA_TUSERDATA: {
- const char *t = lua_xtype(L, 1);
- if (strcmp(t, "userdata") == 0)
- sprintf(buff, "userdata(%d): %p", lua_tag(L, 1), lua_touserdata(L, 1));
+ const l_char *t = lua_xtype(L, 1);
+ if (strcmp(t, l_s("userdata")) == 0)
+ sprintf(buff, l_s("userdata(%d): %p"), lua_tag(L, 1), lua_touserdata(L, 1));
else
- sprintf(buff, "%.40s: %p", t, lua_touserdata(L, 1));
+ sprintf(buff, l_s("%.40s: %p"), t, lua_touserdata(L, 1));
break;
}
case LUA_TNIL:
- lua_pushliteral(L, "nil");
+ lua_pushliteral(L, l_s("nil"));
return 1;
default:
- luaL_argerror(L, 1, "value expected");
+ luaL_argerror(L, 1, l_s("value expected"));
}
lua_pushstring(L, buff);
return 1;
@@ -407,7 +407,7 @@ static int luaB_foreach (lua_State *L) {
static int luaB_assert (lua_State *L) {
luaL_checkany(L, 1);
if (lua_isnil(L, 1))
- luaL_verror(L, "assertion failed! %.90s", luaL_opt_string(L, 2, ""));
+ luaL_verror(L, l_s("assertion failed! %.90s"), luaL_opt_string(L, 2, l_s("")));
lua_settop(L, 1);
return 1;
}
@@ -429,7 +429,7 @@ static int luaB_tinsert (lua_State *L) {
pos = n+1;
else
pos = luaL_check_int(L, 2); /* 2nd argument is the position */
- lua_pushliteral(L, "n");
+ lua_pushliteral(L, l_s("n"));
lua_pushnumber(L, n+1);
lua_rawset(L, 1); /* t.n = n+1 */
for (; n>=pos; n--) {
@@ -453,7 +453,7 @@ static int luaB_tremove (lua_State *L) {
lua_rawgeti(L, 1, pos+1);
lua_rawseti(L, 1, pos); /* a[pos] = a[pos+1] */
}
- lua_pushliteral(L, "n");
+ lua_pushliteral(L, l_s("n"));
lua_pushnumber(L, n-1);
lua_rawset(L, 1); /* t.n = n-1 */
lua_pushnil(L);
@@ -527,12 +527,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, "invalid order function for sorting");
+ if (i>u) lua_error(L, l_s("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, "invalid order function for sorting");
+ if (j<l) lua_error(L, l_s("invalid order function for sorting"));
lua_pop(L, 1); /* remove a[j] */
}
if (j<i) {
@@ -581,10 +581,10 @@ static int luaB_sort (lua_State *L) {
#define num_deprecated 4
static const luaL_reg deprecated_names [num_deprecated] = {
- {"foreachvar", luaB_foreach},
- {"nextvar", luaB_next},
- {"rawgetglobal", luaB_rawget},
- {"rawsetglobal", luaB_rawset}
+ {l_s("foreachvar"), luaB_foreach},
+ {l_s("nextvar"), luaB_next},
+ {l_s("rawgetglobal"), luaB_rawget},
+ {l_s("rawsetglobal"), luaB_rawset}
};
@@ -618,7 +618,7 @@ static void deprecated_funcs (lua_State *L) {
** gives an explicit error in any attempt to call a deprecated function
*/
static int deprecated_func (lua_State *L) {
- luaL_verror(L, "function `%.20s' is deprecated", lua_tostring(L, -1));
+ luaL_verror(L, l_s("function `%.20s' is deprecated"), lua_tostring(L, -1));
return 0; /* to avoid warnings */
}
@@ -637,49 +637,49 @@ static void deprecated_funcs (lua_State *L) {
/* }====================================================== */
static const luaL_reg base_funcs[] = {
- {LUA_ALERT, luaB__ALERT},
- {LUA_ERRORMESSAGE, luaB__ERRORMESSAGE},
- {"call", luaB_call},
- {"collectgarbage", luaB_collectgarbage},
- {"copytagmethods", luaB_copytagmethods},
- {"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},
- {"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 */
- {"setglobal", luaB_setglobal},
- {"settag", luaB_settag},
- {"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},
- {"xtype", luaB_xtype},
+ {l_s(LUA_ALERT), luaB__ALERT},
+ {l_s(LUA_ERRORMESSAGE), luaB__ERRORMESSAGE},
+ {l_s("call"), luaB_call},
+ {l_s("collectgarbage"), luaB_collectgarbage},
+ {l_s("copytagmethods"), luaB_copytagmethods},
+ {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("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("setglobal"), luaB_setglobal},
+ {l_s("settag"), luaB_settag},
+ {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("xtype"), luaB_xtype},
};
LUALIB_API void lua_baselibopen (lua_State *L) {
luaL_openl(L, base_funcs);
- lua_pushliteral(L, LUA_VERSION);
- lua_setglobal(L, "_VERSION");
+ lua_pushliteral(L, l_s(LUA_VERSION));
+ lua_setglobal(L, l_s("_VERSION"));
deprecated_funcs(L);
}
diff --git a/lcode.c b/lcode.c
index 1c3ffedd..6997272f 100644
--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
/*
-** $Id: lcode.c,v 1.61 2001/02/08 11:19:10 roberto Exp roberto $
+** $Id: lcode.c,v 1.62 2001/02/12 19:21:19 roberto Exp roberto $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
@@ -18,7 +18,7 @@
#include "lparser.h"
-void luaK_error (LexState *ls, const char *msg) {
+void luaK_error (LexState *ls, const l_char *msg) {
luaX_error(ls, msg, ls->t.token);
}
@@ -53,7 +53,7 @@ static void luaK_fixjump (FuncState *fs, int pc, int dest) {
else { /* jump is relative to position following jump instruction */
int offset = dest-(pc+1);
if (abs(offset) > MAXARG_S)
- luaK_error(fs->ls, "control structure too long");
+ luaK_error(fs->ls, l_s("control structure too long"));
SETARG_S(*jmp, offset);
}
}
@@ -99,7 +99,7 @@ void luaK_deltastack (FuncState *fs, int delta) {
fs->stacklevel += delta;
if (fs->stacklevel > fs->f->maxstacksize) {
if (fs->stacklevel > MAXSTACK)
- luaK_error(fs->ls, "function or expression too complex");
+ luaK_error(fs->ls, l_s("function or expression too complex"));
fs->f->maxstacksize = (short)fs->stacklevel;
}
}
@@ -119,7 +119,7 @@ static int number_constant (FuncState *fs, lua_Number r) {
if (f->knum[c] == r) return c;
/* not found; create a new entry */
luaM_growvector(fs->L, f->knum, fs->nknum, f->sizeknum, lua_Number,
- MAXARG_U, "constant table overflow");
+ MAXARG_U, l_s("constant table overflow"));
c = fs->nknum++;
f->knum[c] = r;
return c;
@@ -436,11 +436,11 @@ static void codelineinfo (FuncState *fs) {
if (ls->lastline > fs->lastline) {
if (ls->lastline > fs->lastline+1) {
luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int,
- MAX_INT, "line info overflow");
+ MAX_INT, l_s("line info overflow"));
f->lineinfo[fs->nlineinfo++] = -(ls->lastline - (fs->lastline+1));
}
luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int,
- MAX_INT, "line info overflow");
+ MAX_INT, l_s("line info overflow"));
f->lineinfo[fs->nlineinfo++] = fs->pc;
fs->lastline = ls->lastline;
}
@@ -660,7 +660,7 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
codelineinfo(fs);
/* put new instruction in code array */
luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
- MAX_INT, "code size overflow");
+ MAX_INT, l_s("code size overflow"));
f->code[fs->pc] = i;
return fs->pc++;
}
diff --git a/lcode.h b/lcode.h
index 41b8a55b..b73e9947 100644
--- a/lcode.h
+++ b/lcode.h
@@ -1,5 +1,5 @@
/*
-** $Id: lcode.h,v 1.19 2001/01/29 15:26:40 roberto Exp roberto $
+** $Id: lcode.h,v 1.20 2001/02/20 18:15:33 roberto Exp roberto $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
@@ -47,7 +47,7 @@ typedef struct OpProperties {
extern const OpProperties luaK_opproperties[];
-void luaK_error (LexState *ls, const char *msg);
+void luaK_error (LexState *ls, const l_char *msg);
int luaK_code0 (FuncState *fs, OpCode o);
int luaK_code1 (FuncState *fs, OpCode o, int arg1);
int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2);
diff --git a/ldblib.c b/ldblib.c
index 73024335..906a0754 100644
--- a/ldblib.c
+++ b/ldblib.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldblib.c,v 1.31 2001/01/10 16:58:11 roberto Exp roberto $
+** $Id: ldblib.c,v 1.32 2001/02/02 19:02:40 roberto Exp roberto $
** Interface from Lua to its debug API
** See Copyright Notice in lua.h
*/
@@ -17,14 +17,14 @@
-static void settabss (lua_State *L, const char *i, const char *v) {
+static void settabss (lua_State *L, const l_char *i, const l_char *v) {
lua_pushstring(L, i);
lua_pushstring(L, v);
lua_settable(L, -3);
}
-static void settabsi (lua_State *L, const char *i, int v) {
+static void settabsi (lua_State *L, const l_char *i, int v) {
lua_pushstring(L, i);
lua_pushnumber(L, v);
lua_settable(L, -3);
@@ -33,8 +33,8 @@ static void settabsi (lua_State *L, const char *i, int v) {
static int getinfo (lua_State *L) {
lua_Debug ar;
- const char *options = luaL_opt_string(L, 2, "flnSu");
- char buff[20];
+ const l_char *options = luaL_opt_string(L, 2, l_s("flnSu"));
+ l_char buff[20];
if (lua_isnumber(L, 1)) {
if (!lua_getstack(L, (int)lua_tonumber(L, 1), &ar)) {
lua_pushnil(L); /* level out of range */
@@ -43,35 +43,35 @@ static int getinfo (lua_State *L) {
}
else if (lua_isfunction(L, 1)) {
lua_pushvalue(L, 1);
- sprintf(buff, ">%.10s", options);
+ sprintf(buff, l_s(">%.10s"), options);
options = buff;
}
else
- luaL_argerror(L, 1, "function or level expected");
+ luaL_argerror(L, 1, l_s("function or level expected"));
if (!lua_getinfo(L, options, &ar))
- luaL_argerror(L, 2, "invalid option");
+ luaL_argerror(L, 2, l_s("invalid option"));
lua_newtable(L);
for (; *options; options++) {
switch (*options) {
- case 'S':
- settabss(L, "source", ar.source);
+ case l_c('S'):
+ settabss(L, l_s("source"), ar.source);
if (ar.source)
- settabss(L, "short_src", ar.short_src);
- settabsi(L, "linedefined", ar.linedefined);
- settabss(L, "what", ar.what);
+ settabss(L, l_s("short_src"), ar.short_src);
+ settabsi(L, l_s("linedefined"), ar.linedefined);
+ settabss(L, l_s("what"), ar.what);
break;
- case 'l':
- settabsi(L, "currentline", ar.currentline);
+ case l_c('l'):
+ settabsi(L, l_s("currentline"), ar.currentline);
break;
- case 'u':
- settabsi(L, "nups", ar.nups);
+ case l_c('u'):
+ settabsi(L, l_s("nups"), ar.nups);
break;
- case 'n':
- settabss(L, "name", ar.name);
- settabss(L, "namewhat", ar.namewhat);
+ case l_c('n'):
+ settabss(L, l_s("name"), ar.name);
+ settabss(L, l_s("namewhat"), ar.namewhat);
break;
- case 'f':
- lua_pushliteral(L, "func");
+ case l_c('f'):
+ lua_pushliteral(L, l_s("func"));
lua_pushvalue(L, -3);
lua_settable(L, -3);
break;
@@ -83,9 +83,9 @@ static int getinfo (lua_State *L) {
static int getlocal (lua_State *L) {
lua_Debug ar;
- const char *name;
+ const l_char *name;
if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */
- luaL_argerror(L, 1, "level out of range");
+ luaL_argerror(L, 1, l_s("level out of range"));
name = lua_getlocal(L, &ar, luaL_check_int(L, 2));
if (name) {
lua_pushstring(L, name);
@@ -102,7 +102,7 @@ static int getlocal (lua_State *L) {
static int setlocal (lua_State *L) {
lua_Debug ar;
if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */
- luaL_argerror(L, 1, "level out of range");
+ luaL_argerror(L, 1, l_s("level out of range"));
luaL_checkany(L, 3);
lua_pushstring(L, lua_setlocal(L, &ar, luaL_check_int(L, 2)));
return 1;
@@ -111,7 +111,7 @@ static int setlocal (lua_State *L) {
/* dummy variables (to define unique addresses) */
-static const char key1[] = "ab";
+static const l_char key1[] = l_s("ab");
#define KEY_CALLHOOK ((void *)key1)
#define KEY_LINEHOOK ((void *)(key1+1))
@@ -150,7 +150,7 @@ static void sethook (lua_State *L, void *key, lua_Hook hook,
else if (lua_isfunction(L, 1))
(*sethookf)(L, hook);
else
- luaL_argerror(L, 1, "function expected");
+ luaL_argerror(L, 1, l_s("function expected"));
lua_getregistry(L);
lua_pushuserdata(L, key);
lua_pushvalue(L, -1); /* dup key */
@@ -174,11 +174,11 @@ static int setlinehook (lua_State *L) {
static const luaL_reg dblib[] = {
- {"getlocal", getlocal},
- {"getinfo", getinfo},
- {"setcallhook", setcallhook},
- {"setlinehook", setlinehook},
- {"setlocal", setlocal}
+ {l_s("getlocal"), getlocal},
+ {l_s("getinfo"), getinfo},
+ {l_s("setcallhook"), setcallhook},
+ {l_s("setlinehook"), setlinehook},
+ {l_s("setlocal"), setlocal}
};
diff --git a/ldebug.c b/ldebug.c
index 7c605638..e42a9028 100644
--- a/ldebug.c
+++ b/ldebug.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldebug.c,v 1.67 2001/02/21 16:52:09 roberto Exp roberto $
+** $Id: ldebug.c,v 1.68 2001/02/22 18:59:59 roberto Exp roberto $
** Debug Interface
** See Copyright Notice in lua.h
*/
@@ -24,7 +24,7 @@
-static const char *getfuncname (lua_State *L, StkId f, const char **name);
+static const l_char *getfuncname (lua_State *L, StkId f, const l_char **name);
static void setnormalized (TObject *d, const TObject *s) {
@@ -158,8 +158,8 @@ static Proto *getluaproto (StkId f) {
}
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
- const char *name;
+LUA_API const l_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+ const l_char *name;
StkId f;
Proto *fp;
LUA_LOCK(L);
@@ -176,8 +176,8 @@ LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
}
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
- const char *name;
+LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
+ const l_char *name;
StkId f;
Proto *fp;
LUA_LOCK(L);
@@ -187,7 +187,7 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
L->top--; /* pop new value */
if (fp) { /* `f' is a Lua function? */
name = luaF_getlocalname(fp, n, currentpc(f));
- if (!name || name[0] == '(') /* `(' starts private locals */
+ if (!name || name[0] == l_c('(')) /* `(' starts private locals */
name = NULL;
else
setobj((f+1)+(n-1), L->top);
@@ -200,7 +200,7 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
static void infoLproto (lua_Debug *ar, Proto *f) {
ar->source = getstr(f->source);
ar->linedefined = f->lineDefined;
- ar->what = "Lua";
+ ar->what = l_s("Lua");
}
@@ -214,22 +214,22 @@ static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) {
cl = infovalue(func)->func;
break;
default:
- luaD_error(L, "value for `lua_getinfo' is not a function");
+ luaD_error(L, l_s("value for `lua_getinfo' is not a function"));
}
if (cl->isC) {
- ar->source = "=C";
+ ar->source = l_s("=C");
ar->linedefined = -1;
- ar->what = "C";
+ ar->what = l_s("C");
}
else
infoLproto(ar, cl->f.l);
luaO_chunkid(ar->short_src, ar->source, sizeof(ar->short_src));
if (ar->linedefined == 0)
- ar->what = "main";
+ ar->what = l_s("main");
}
-static const char *travtagmethods (global_State *G, const TObject *o) {
+static const l_char *travtagmethods (global_State *G, const TObject *o) {
if (ttype(o) == LUA_TFUNCTION) {
int e;
for (e=0; e<TM_N; e++) {
@@ -243,7 +243,7 @@ static const char *travtagmethods (global_State *G, const TObject *o) {
}
-static const char *travglobals (lua_State *L, const TObject *o) {
+static const l_char *travglobals (lua_State *L, const TObject *o) {
Hash *g = L->gt;
int i;
for (i=0; i<g->size; i++) {
@@ -260,20 +260,20 @@ static void getname (lua_State *L, StkId f, lua_Debug *ar) {
setnormalized(&o, f);
/* try to find a name for given function */
if ((ar->name = travglobals(L, &o)) != NULL)
- ar->namewhat = "global";
+ ar->namewhat = l_s("global");
/* not found: try tag methods */
else if ((ar->name = travtagmethods(G(L), &o)) != NULL)
- ar->namewhat = "tag-method";
- else ar->namewhat = ""; /* not found at all */
+ ar->namewhat = l_s("tag-method");
+ else ar->namewhat = l_s(""); /* not found at all */
}
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
+LUA_API int lua_getinfo (lua_State *L, const l_char *what, lua_Debug *ar) {
StkId func;
int isactive;
int status = 1;
LUA_LOCK(L);
- isactive = (*what != '>');
+ isactive = (*what != l_c('>'));
if (isactive)
func = ar->_func;
else {
@@ -282,25 +282,25 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
}
for (; *what; what++) {
switch (*what) {
- case 'S': {
+ case l_c('S'): {
funcinfo(L, ar, func);
break;
}
- case 'l': {
+ case l_c('l'): {
ar->currentline = currentline(func);
break;
}
- case 'u': {
+ case l_c('u'): {
ar->nups = nups(func);
break;
}
- case 'n': {
+ case l_c('n'): {
ar->namewhat = (isactive) ? getfuncname(L, func, &ar->name) : NULL;
if (ar->namewhat == NULL)
getname(L, func, ar);
break;
}
- case 'f': {
+ case l_c('f'): {
setnormalized(L->top, func);
incr_top; /* push function */
break;
@@ -543,7 +543,7 @@ int luaG_checkcode (lua_State *L, const Proto *pt) {
}
-static const char *getobjname (lua_State *L, StkId obj, const char **name) {
+static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) {
StkId func = aux_stackedfunction(L, 0, obj);
if (!isLmark(func))
return NULL; /* not an active Lua function */
@@ -556,17 +556,17 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
switch (GET_OPCODE(i)) {
case OP_GETGLOBAL: {
*name = getstr(p->kstr[GETARG_U(i)]);
- return "global";
+ return l_s("global");
}
case OP_GETLOCAL: {
*name = luaF_getlocalname(p, GETARG_U(i)+1, pc);
lua_assert(*name);
- return "local";
+ return l_s("local");
}
case OP_PUSHSELF:
case OP_GETDOTTED: {
*name = getstr(p->kstr[GETARG_U(i)]);
- return "field";
+ return l_s("field");
}
default:
return NULL; /* no useful name found */
@@ -575,7 +575,7 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
}
-static const char *getfuncname (lua_State *L, StkId f, const char **name) {
+static const l_char *getfuncname (lua_State *L, StkId f, const l_char **name) {
StkId func = aux_stackedfunction(L, 0, f); /* calling function */
if (!isLmark(func))
return NULL; /* not an active Lua function */
@@ -595,19 +595,19 @@ static const char *getfuncname (lua_State *L, StkId f, const char **name) {
}
-void luaG_typeerror (lua_State *L, StkId o, const char *op) {
- const char *name;
- const char *kind = getobjname(L, o, &name);
- const char *t = luaT_typename(G(L), o);
+void luaG_typeerror (lua_State *L, StkId o, const l_char *op) {
+ const l_char *name;
+ const l_char *kind = getobjname(L, o, &name);
+ const l_char *t = luaT_typename(G(L), o);
if (kind)
- luaO_verror(L, "attempt to %.30s %.20s `%.40s' (a %.10s value)",
+ luaO_verror(L, l_s("attempt to %.30s %.20s `%.40s' (a %.10s value)"),
op, kind, name, t);
else
- luaO_verror(L, "attempt to %.30s a %.10s value", op, t);
+ luaO_verror(L, l_s("attempt to %.30s a %.10s value"), op, t);
}
-void luaG_binerror (lua_State *L, StkId p1, int t, const char *op) {
+void luaG_binerror (lua_State *L, StkId p1, int t, const l_char *op) {
if (ttype(p1) == t) p1++;
lua_assert(ttype(p1) != t);
luaG_typeerror(L, p1, op);
@@ -615,11 +615,11 @@ void luaG_binerror (lua_State *L, StkId p1, int t, const char *op) {
void luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) {
- const char *t1 = luaT_typename(G(L), p1);
- const char *t2 = luaT_typename(G(L), p2);
+ const l_char *t1 = luaT_typename(G(L), p1);
+ const l_char *t2 = luaT_typename(G(L), p2);
if (t1[2] == t2[2])
- luaO_verror(L, "attempt to compare two %.10s values", t1);
+ luaO_verror(L, l_s("attempt to compare two %.10s values"), t1);
else
- luaO_verror(L, "attempt to compare %.10s with %.10s", t1, t2);
+ luaO_verror(L, l_s("attempt to compare %.10s with %.10s"), t1, t2);
}
diff --git a/ldebug.h b/ldebug.h
index 447b4b68..9bdc7c03 100644
--- a/ldebug.h
+++ b/ldebug.h
@@ -1,5 +1,5 @@
/*
-** $Id: ldebug.h,v 1.9 2001/02/09 18:37:33 roberto Exp roberto $
+** $Id: ldebug.h,v 1.10 2001/02/12 19:54:50 roberto Exp roberto $
** Auxiliary functions from Debug Interface module
** See Copyright Notice in lua.h
*/
@@ -12,8 +12,8 @@
#include "luadebug.h"
-void luaG_typeerror (lua_State *L, StkId o, const char *op);
-void luaG_binerror (lua_State *L, StkId p1, int t, const char *op);
+void luaG_typeerror (lua_State *L, StkId o, const l_char *op);
+void luaG_binerror (lua_State *L, StkId p1, int t, const l_char *op);
int luaG_getline (int *lineinfo, int pc, int refline, int *refi);
void luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2);
int luaG_checkcode (lua_State *L, const Proto *pt);
diff --git a/ldo.c b/ldo.c
index 30c0c241..84a2c985 100644
--- a/ldo.c
+++ b/ldo.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldo.c,v 1.126 2001/02/22 18:59:59 roberto Exp roberto $
+** $Id: ldo.c,v 1.127 2001/02/23 13:38:56 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@@ -56,7 +56,7 @@ void luaD_checkstack (lua_State *L, int n) {
else {
L->stack_last += EXTRA_STACK; /* to be used by error message */
lua_assert(L->stack_last == L->stack+L->stacksize-1);
- luaD_error(L, "stack overflow");
+ luaD_error(L, l_s("stack overflow"));
}
}
}
@@ -108,7 +108,7 @@ void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook) {
if (L->allowhooks) {
lua_Debug ar;
ar._func = func;
- ar.event = "line";
+ ar.event = l_s("line");
ar.currentline = line;
dohook(L, &ar, linehook);
}
@@ -116,7 +116,7 @@ void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook) {
static void luaD_callHook (lua_State *L, StkId func, lua_Hook callhook,
- const char *event) {
+ const l_char *event) {
if (L->allowhooks) {
lua_Debug ar;
ar._func = func;
@@ -159,7 +159,7 @@ void luaD_call (lua_State *L, StkId func, int nResults) {
/* `func' is not a function; check the `function' tag method */
Closure *tm = luaT_gettmbyObj(G(L), func, TM_FUNCTION);
if (tm == NULL)
- luaG_typeerror(L, func, "call");
+ luaG_typeerror(L, func, l_s("call"));
luaD_openstack(L, func);
setclvalue(func, tm); /* tag method is the new function to be called */
}
@@ -168,11 +168,11 @@ void luaD_call (lua_State *L, StkId func, int nResults) {
setivalue(func, &ci);
callhook = L->callhook;
if (callhook)
- luaD_callHook(L, func, callhook, "call");
+ luaD_callHook(L, func, callhook, l_s("call"));
firstResult = (cl->isC ? callCclosure(L, cl, func+1) :
luaV_execute(L, cl, func+1));
if (callhook) /* same hook that was active at entry */
- luaD_callHook(L, func, callhook, "return");
+ luaD_callHook(L, func, callhook, l_s("return"));
lua_assert(ttype(func) == LUA_TMARK);
setnilvalue(func); /* remove callinfo from the stack */
/* move results to `func' (to erase parameters and function) */
@@ -261,20 +261,20 @@ static int protectedparser (lua_State *L, ZIO *z, int bin) {
}
-static int parse_file (lua_State *L, const char *filename) {
+static int parse_file (lua_State *L, const l_char *filename) {
ZIO z;
int status;
int bin; /* flag for file mode */
- FILE *f = (filename == NULL) ? stdin : fopen(filename, "r");
+ FILE *f = (filename == NULL) ? stdin : fopen(filename, l_s("r"));
if (f == NULL) return LUA_ERRFILE; /* unable to open file */
bin = (ungetc(fgetc(f), f) == ID_CHUNK);
if (bin && f != stdin) {
fclose(f);
- f = fopen(filename, "rb"); /* reopen in binary mode */
+ f = fopen(filename, l_s("rb")); /* reopen in binary mode */
if (f == NULL) return LUA_ERRFILE; /* unable to reopen file */
}
- lua_pushliteral(L, "@");
- lua_pushstring(L, (filename == NULL) ? "(stdin)" : filename);
+ lua_pushliteral(L, l_s("@"));
+ lua_pushstring(L, (filename == NULL) ? l_s("(stdin)") : filename);
lua_concat(L, 2);
filename = lua_tostring(L, -1); /* filename = `@'..filename */
luaZ_Fopen(&z, f, filename);
@@ -286,7 +286,7 @@ static int parse_file (lua_State *L, const char *filename) {
}
-LUA_API int lua_dofile (lua_State *L, const char *filename) {
+LUA_API int lua_dofile (lua_State *L, const l_char *filename) {
int status;
status = parse_file(L, filename);
if (status == 0) /* parse OK? */
@@ -295,18 +295,18 @@ LUA_API int lua_dofile (lua_State *L, const char *filename) {
}
-static int parse_buffer (lua_State *L, const char *buff, size_t size,
- const char *name) {
+static int parse_buffer (lua_State *L, const l_char *buff, size_t size,
+ const l_char *name) {
ZIO z;
int status;
- if (!name) name = "?";
+ if (!name) name = l_s("?");
luaZ_mopen(&z, buff, size, name);
status = protectedparser(L, &z, buff[0]==ID_CHUNK);
return status;
}
-LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, const char *name) {
+LUA_API int lua_dobuffer (lua_State *L, const l_char *buff, size_t size, const l_char *name) {
int status;
status = parse_buffer(L, buff, size, name);
if (status == 0) /* parse OK? */
@@ -315,7 +315,7 @@ LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, const cha
}
-LUA_API int lua_dostring (lua_State *L, const char *str) {
+LUA_API int lua_dostring (lua_State *L, const l_char *str) {
return lua_dobuffer(L, str, strlen(str), str);
}
@@ -334,8 +334,8 @@ struct lua_longjmp {
};
-static void message (lua_State *L, const char *s) {
- luaV_getglobal(L, luaS_newliteral(L, LUA_ERRORMESSAGE), L->top);
+static void message (lua_State *L, const l_char *s) {
+ luaV_getglobal(L, luaS_newliteral(L, l_s(LUA_ERRORMESSAGE)), L->top);
if (ttype(L->top) == LUA_TFUNCTION) {
incr_top;
setsvalue(L->top, luaS_new(L, s));
@@ -348,7 +348,7 @@ static void message (lua_State *L, const char *s) {
/*
** Reports an error, and jumps up to the available recovery label
*/
-void luaD_error (lua_State *L, const char *s) {
+void luaD_error (lua_State *L, const l_char *s) {
if (s) message(L, s);
luaD_breakrun(L, LUA_ERRRUN);
}
@@ -361,7 +361,7 @@ void luaD_breakrun (lua_State *L, int errcode) {
}
else {
if (errcode != LUA_ERRMEM)
- message(L, "unable to recover; exiting\n");
+ message(L, l_s("unable to recover; exiting\n"));
exit(EXIT_FAILURE);
}
}
diff --git a/ldo.h b/ldo.h
index 2cd9a91c..b4bc94c5 100644
--- a/ldo.h
+++ b/ldo.h
@@ -1,5 +1,5 @@
/*
-** $Id: ldo.h,v 1.29 2001/01/24 15:45:33 roberto Exp roberto $
+** $Id: ldo.h,v 1.30 2001/02/07 18:13:49 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@@ -25,7 +25,7 @@ void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook);
void luaD_call (lua_State *L, StkId func, int nResults);
void luaD_checkstack (lua_State *L, int n);
-void luaD_error (lua_State *L, const char *s);
+void luaD_error (lua_State *L, const l_char *s);
void luaD_breakrun (lua_State *L, int errcode);
int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud);
diff --git a/lfunc.c b/lfunc.c
index 3b8dfd21..7d6353cc 100644
--- a/lfunc.c
+++ b/lfunc.c
@@ -1,5 +1,5 @@
/*
-** $Id: lfunc.c,v 1.40 2001/02/09 20:22:29 roberto Exp roberto $
+** $Id: lfunc.c,v 1.41 2001/02/20 18:28:11 roberto Exp roberto $
** Auxiliary functions to manipulate prototypes and closures
** See Copyright Notice in lua.h
*/
@@ -74,7 +74,7 @@ void luaF_freeclosure (lua_State *L, Closure *c) {
** Look for n-th local variable at line `line' in function `func'.
** Returns NULL if not found.
*/
-const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+const l_char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
int i;
for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
if (pc < f->locvars[i].endpc) { /* is variable active? */
diff --git a/lfunc.h b/lfunc.h
index b78578a6..e5bcdca1 100644
--- a/lfunc.h
+++ b/lfunc.h
@@ -1,5 +1,5 @@
/*
-** $Id: lfunc.h,v 1.13 2000/09/29 12:42:13 roberto Exp roberto $
+** $Id: lfunc.h,v 1.14 2000/12/28 12:55:41 roberto Exp roberto $
** Auxiliary functions to manipulate prototypes and closures
** See Copyright Notice in lua.h
*/
@@ -17,7 +17,7 @@ Closure *luaF_newclosure (lua_State *L, int nelems);
void luaF_freeproto (lua_State *L, Proto *f);
void luaF_freeclosure (lua_State *L, Closure *c);
-const char *luaF_getlocalname (const Proto *func, int local_number, int pc);
+const l_char *luaF_getlocalname (const Proto *func, int local_number, int pc);
#endif
diff --git a/lgc.c b/lgc.c
index 73c841b0..9ab871bd 100644
--- a/lgc.c
+++ b/lgc.c
@@ -1,5 +1,5 @@
/*
-** $Id: lgc.c,v 1.90 2001/02/20 18:28:11 roberto Exp roberto $
+** $Id: lgc.c,v 1.91 2001/02/22 18:59:59 roberto Exp roberto $
** Garbage Collector
** See Copyright Notice in lua.h
*/
@@ -331,7 +331,7 @@ static void collectudata (lua_State *L, int all) {
static void checkMbuffer (lua_State *L) {
if (G(L)->Mbuffsize > MINBUFFER*2) { /* is buffer too big? */
size_t newsize = G(L)->Mbuffsize/2; /* still larger than MINBUFFER */
- luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, char);
+ luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, l_char);
G(L)->Mbuffsize = newsize;
}
}
diff --git a/liolib.c b/liolib.c
index f9aa2716..379a8ca7 100644
--- a/liolib.c
+++ b/liolib.c
@@ -1,5 +1,5 @@
/*
-** $Id: liolib.c,v 1.106 2001/02/09 19:52:54 roberto Exp roberto $
+** $Id: liolib.c,v 1.107 2001/02/22 17:15:18 roberto Exp roberto $
** Standard I/O (and system) library
** See Copyright Notice in lua.h
*/
@@ -47,10 +47,10 @@ int pclose(); */
#define OUTFILE 1
#define NOFILE 2
-#define FILEHANDLE "FileHandle"
+#define FILEHANDLE l_s("FileHandle")
-static const char *const filenames[] = {"_INPUT", "_OUTPUT"};
+static const l_char *const filenames[] = {l_s("_INPUT"), l_s("_OUTPUT")};
static int pushresult (lua_State *L, int i) {
@@ -81,10 +81,10 @@ static FILE *getopthandle (lua_State *L, int inout) {
FILE *p = (FILE *)lua_touserdata(L, 1);
if (p != NULL) { /* is it a userdata ? */
if (!checkfile(L, 1)) {
- if (strcmp(lua_xtype(L, 1), "ClosedFileHandle") == 0)
- luaL_argerror(L, 1, "file is closed");
+ if (strcmp(lua_xtype(L, 1), l_s("ClosedFileHandle")) == 0)
+ luaL_argerror(L, 1, l_s("file is closed"));
else
- luaL_argerror(L, 1, "(invalid value)");
+ luaL_argerror(L, 1, l_s("(invalid value)"));
}
/* move it to stack top */
lua_pushvalue(L, 1); lua_remove(L, 1);
@@ -92,7 +92,7 @@ static FILE *getopthandle (lua_State *L, int inout) {
else if (inout != NOFILE) { /* try global value */
lua_getglobal(L, filenames[inout]);
if (!checkfile(L,-1))
- luaL_verror(L, "global variable `%.10s' is not a valid file handle",
+ luaL_verror(L, l_s("global variable `%.10s' is not a valid file handle"),
filenames[inout]);
p = (FILE *)lua_touserdata(L, -1);
}
@@ -105,7 +105,7 @@ static void pushfile (lua_State *L, FILE *f) {
}
-static void setfilebyname (lua_State *L, FILE *f, const char *name) {
+static void setfilebyname (lua_State *L, FILE *f, const l_char *name) {
pushfile(L, f);
lua_setglobal(L, name);
}
@@ -131,7 +131,7 @@ static int closefile (lua_State *L, FILE *f) {
return 1;
else {
lua_pushuserdata(L, f);
- lua_settag(L, lua_type2tag(L, "ClosedFileHandle"));
+ lua_settag(L, lua_type2tag(L, l_s("ClosedFileHandle")));
return (CLOSEFILE(L, f) == 0);
}
}
@@ -163,7 +163,7 @@ static int io_tmpfile (lua_State *L) {
-static int io_fromto (lua_State *L, int inout, const char *mode) {
+static int io_fromto (lua_State *L, int inout, const l_char *mode) {
FILE *current;
if (lua_isnull(L, 1)) {
closefile(L, getopthandle(L, inout));
@@ -172,25 +172,25 @@ static int io_fromto (lua_State *L, int inout, const char *mode) {
else if (checkfile(L, 1)) /* deprecated option */
current = (FILE *)lua_touserdata(L, 1);
else {
- const char *s = luaL_check_string(L, 1);
- current = (*s == '|') ? popen(s+1, mode) : fopen(s, mode);
+ const l_char *s = luaL_check_string(L, 1);
+ current = (*s == l_c('|')) ? popen(s+1, mode) : fopen(s, mode);
}
return setreturn(L, current, inout);
}
static int io_readfrom (lua_State *L) {
- return io_fromto(L, INFILE, "r");
+ return io_fromto(L, INFILE, l_s("r"));
}
static int io_writeto (lua_State *L) {
- return io_fromto(L, OUTFILE, "w");
+ return io_fromto(L, OUTFILE, l_s("w"));
}
static int io_appendto (lua_State *L) {
- FILE *current = fopen(luaL_check_string(L, 1), "a");
+ FILE *current = fopen(luaL_check_string(L, 1), l_s("a"));
return setreturn(L, current, OUTFILE);
}
@@ -205,7 +205,7 @@ static int io_appendto (lua_State *L) {
static int read_number (lua_State *L, FILE *f) {
double d;
- if (fscanf(f, "%lf", &d) == 1) {
+ if (fscanf(f, l_s("%lf"), &d) == 1) {
lua_pushnumber(L, d);
return 1;
}
@@ -233,11 +233,11 @@ static int read_line (lua_State *L, FILE *f) {
luaL_Buffer b;
luaL_buffinit(L, &b);
for (;;) {
- char *p = luaL_prepbuffer(&b);
+ l_char *p = luaL_prepbuffer(&b);
if (!fgets(p, LUAL_BUFFERSIZE, f)) /* read fails? */
break;
n = strlen(p);
- if (p[n-1] != '\n')
+ if (p[n-1] != l_c('\n'))
luaL_addsize(&b, n);
else {
luaL_addsize(&b, n-1); /* do not add the `\n' */
@@ -253,15 +253,15 @@ static void read_file (lua_State *L, FILE *f) {
size_t len = 0;
size_t size = LUAL_BUFFERSIZE;
size_t oldsize = 0;
- char *buffer = NULL;
+ l_char *buffer = NULL;
for (;;) {
- char *newbuffer = (char *)l_realloc(buffer, oldsize, size);
+ l_char *newbuffer = (l_char *)l_realloc(buffer, oldsize, size);
if (newbuffer == NULL) {
l_free(buffer, oldsize);
- lua_error(L, "not enough memory to read a file");
+ lua_error(L, l_s("not enough memory to read a file"));
}
buffer = newbuffer;
- len += fread(buffer+len, sizeof(char), size-len, f);
+ len += fread(buffer+len, sizeof(l_char), size-len, f);
if (len < size) break; /* did not read all it could */
oldsize = size;
size *= 2;
@@ -279,17 +279,17 @@ static int read_chars (lua_State *L, FILE *f, size_t n) {
return (c != EOF);
}
else {
- char *buffer;
+ l_char *buffer;
size_t n1;
- char statbuff[LUAL_BUFFERSIZE];
+ l_char statbuff[LUAL_BUFFERSIZE];
if (n <= LUAL_BUFFERSIZE)
buffer = statbuff;
else {
- buffer = (char *)l_malloc(n);
+ buffer = (l_char *)l_malloc(n);
if (buffer == NULL)
- lua_error(L, "not enough memory to read a file");
+ lua_error(L, l_s("not enough memory to read a file"));
}
- n1 = fread(buffer, sizeof(char), n, f);
+ n1 = fread(buffer, sizeof(l_char), n, f);
lua_pushlstring(L, buffer, n1);
if (buffer != statbuff) l_free(buffer, n);
return (n1 > 0 || n == 0);
@@ -307,31 +307,31 @@ static int io_read (lua_State *L) {
n = 2; /* will return n-1 results */
}
else { /* ensure stack space for all results and for auxlib's buffer */
- luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
+ luaL_checkstack(L, nargs+LUA_MINSTACK, l_s("too many arguments"));
success = 1;
for (n = 1; n<=nargs && success; n++) {
if (lua_type(L, n) == LUA_TNUMBER)
success = read_chars(L, f, (size_t)lua_tonumber(L, n));
else {
- const char *p = lua_tostring(L, n);
- if (!p || p[0] != '*')
- lua_error(L, "invalid `read' option");
+ const l_char *p = lua_tostring(L, n);
+ if (!p || p[0] != l_c('*'))
+ lua_error(L, l_s("invalid `read' option"));
switch (p[1]) {
- case 'n': /* number */
+ case l_c('n'): /* number */
success = read_number(L, f);
break;
- case 'l': /* line */
+ case l_c('l'): /* line */
success = read_line(L, f);
break;
- case 'a': /* file */
+ case l_c('a'): /* file */
read_file(L, f);
success = 1; /* always success */
break;
- case 'w': /* word */
+ case l_c('w'): /* word */
success = read_word(L, f);
break;
default:
- luaL_argerror(L, n, "invalid format");
+ luaL_argerror(L, n, l_s("invalid format"));
success = 0; /* to avoid warnings */
}
}
@@ -355,12 +355,12 @@ static int io_write (lua_State *L) {
for (arg=1; arg<=nargs; arg++) {
if (lua_type(L, arg) == LUA_TNUMBER) { /* LUA_NUMBER */
/* optimization: could be done exactly as for strings */
- status = status && fprintf(f, "%.16g", lua_tonumber(L, arg)) > 0;
+ status = status && fprintf(f, l_s("%.16g"), lua_tonumber(L, arg)) > 0;
}
else {
size_t l;
- const char *s = luaL_check_lstr(L, arg, &l);
- status = status && (fwrite(s, sizeof(char), l, f) == l);
+ const l_char *s = luaL_check_lstr(L, arg, &l);
+ status = status && (fwrite(s, sizeof(l_char), l, f) == l);
}
}
pushresult(L, status);
@@ -370,11 +370,11 @@ static int io_write (lua_State *L) {
static int io_seek (lua_State *L) {
static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
- static const char *const modenames[] = {"set", "cur", "end", NULL};
+ static const l_char *const modenames[] = {l_s("set"), l_s("cur"), l_s("end"), NULL};
FILE *f = (FILE *)luaL_check_userdata(L, 1, FILEHANDLE);
- int op = luaL_findstring(luaL_opt_string(L, 2, "cur"), modenames);
+ int op = luaL_findstring(luaL_opt_string(L, 2, l_s("cur")), modenames);
long offset = luaL_opt_long(L, 3, 0);
- luaL_arg_check(L, op != -1, 2, "invalid mode");
+ luaL_arg_check(L, op != -1, 2, l_s("invalid mode"));
op = fseek(f, offset, mode[op]);
if (op)
return pushresult(L, 0); /* error */
@@ -387,7 +387,7 @@ static int io_seek (lua_State *L) {
static int io_flush (lua_State *L) {
FILE *f = getopthandle(L, NOFILE);
- luaL_arg_check(L, f || lua_isnull(L, 1), 1, "invalid file handle");
+ luaL_arg_check(L, f || lua_isnull(L, 1), 1, l_s("invalid file handle"));
return pushresult(L, fflush(f) == 0);
}
@@ -418,9 +418,9 @@ static int io_rename (lua_State *L) {
static int io_tmpname (lua_State *L) {
- char buff[L_tmpnam];
+ l_char buff[L_tmpnam];
if (tmpnam(buff) != buff)
- lua_error(L, "unable to generate a unique filename");
+ lua_error(L, l_s("unable to generate a unique filename"));
lua_pushstring(L, buff);
return 1;
}
@@ -447,14 +447,14 @@ static int io_clock (lua_State *L) {
** =======================================================
*/
-static void setfield (lua_State *L, const char *key, int value) {
+static void setfield (lua_State *L, const l_char *key, int value) {
lua_pushstring(L, key);
lua_pushnumber(L, value);
lua_rawset(L, -3);
}
-static int getfield (lua_State *L, const char *key, int d) {
+static int getfield (lua_State *L, const l_char *key, int d) {
int res;
lua_pushstring(L, key);
lua_rawget(L, -2);
@@ -462,7 +462,7 @@ static int getfield (lua_State *L, const char *key, int d) {
res = (int)lua_tonumber(L, -1);
else {
if (d == -2)
- luaL_verror(L, "field `%.20s' missing in date table", key);
+ luaL_verror(L, l_s("field `%.20s' missing in date table"), key);
res = d;
}
lua_pop(L, 1);
@@ -471,12 +471,12 @@ static int getfield (lua_State *L, const char *key, int d) {
static int io_date (lua_State *L) {
- const char *s = luaL_opt_string(L, 1, "%c");
+ const l_char *s = luaL_opt_string(L, 1, l_s("%c"));
time_t t = (time_t)luaL_opt_number(L, 2, -1);
struct tm *stm;
if (t == (time_t)-1) /* no time given? */
t = time(NULL); /* use current time */
- if (*s == '!') { /* UTC? */
+ if (*s == l_c('!')) { /* UTC? */
stm = gmtime(&t);
s++; /* skip `!' */
}
@@ -484,24 +484,24 @@ static int io_date (lua_State *L) {
stm = localtime(&t);
if (stm == NULL) /* invalid date? */
lua_pushnil(L);
- else if (strcmp(s, "*t") == 0) {
+ else if (strcmp(s, l_s("*t")) == 0) {
lua_newtable(L);
- setfield(L, "sec", stm->tm_sec);
- setfield(L, "min", stm->tm_min);
- setfield(L, "hour", stm->tm_hour);
- setfield(L, "day", stm->tm_mday);
- setfield(L, "month", stm->tm_mon+1);
- setfield(L, "year", stm->tm_year+1900);
- setfield(L, "wday", stm->tm_wday+1);
- setfield(L, "yday", stm->tm_yday+1);
- setfield(L, "isdst", stm->tm_isdst);
+ setfield(L, l_s("sec"), stm->tm_sec);
+ setfield(L, l_s("min"), stm->tm_min);
+ setfield(L, l_s("hour"), stm->tm_hour);
+ setfield(L, l_s("day"), stm->tm_mday);
+ setfield(L, l_s("month"), stm->tm_mon+1);
+ setfield(L, l_s("year"), stm->tm_year+1900);
+ setfield(L, l_s("wday"), stm->tm_wday+1);
+ setfield(L, l_s("yday"), stm->tm_yday+1);
+ setfield(L, l_s("isdst"), stm->tm_isdst);
}
else {
- char b[256];
+ l_char b[256];
if (strftime(b, sizeof(b), s, stm))
lua_pushstring(L, b);
else
- lua_error(L, "invalid `date' format");
+ lua_error(L, l_s("invalid `date' format"));
}
return 1;
}
@@ -515,13 +515,13 @@ static int io_time (lua_State *L) {
struct tm ts;
luaL_checktype(L, 1, LUA_TTABLE);
lua_settop(L, 1); /* make sure table is at the top */
- ts.tm_sec = getfield(L, "sec", 0);
- ts.tm_min = getfield(L, "min", 0);
- ts.tm_hour = getfield(L, "hour", 12);
- ts.tm_mday = getfield(L, "day", -2);
- ts.tm_mon = getfield(L, "month", -2)-1;
- ts.tm_year = getfield(L, "year", -2)-1900;
- ts.tm_isdst = getfield(L, "isdst", -1);
+ ts.tm_sec = getfield(L, l_s("sec"), 0);
+ ts.tm_min = getfield(L, l_s("min"), 0);
+ ts.tm_hour = getfield(L, l_s("hour"), 12);
+ ts.tm_mday = getfield(L, l_s("day"), -2);
+ ts.tm_mon = getfield(L, l_s("month"), -2)-1;
+ ts.tm_year = getfield(L, l_s("year"), -2)-1900;
+ ts.tm_isdst = getfield(L, l_s("isdst"), -1);
t = mktime(&ts);
if (t == (time_t)-1)
lua_pushnil(L);
@@ -544,10 +544,10 @@ static int io_difftime (lua_State *L) {
static int io_setloc (lua_State *L) {
static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
LC_NUMERIC, LC_TIME};
- static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
- "numeric", "time", NULL};
- int op = luaL_findstring(luaL_opt_string(L, 2, "all"), catnames);
- luaL_arg_check(L, op != -1, 2, "invalid option");
+ static const l_char *const catnames[] = {l_s("all"), l_s("collate"), l_s("ctype"), l_s("monetary"),
+ l_s("numeric"), l_s("time"), NULL};
+ int op = luaL_findstring(luaL_opt_string(L, 2, l_s("all")), catnames);
+ luaL_arg_check(L, op != -1, 2, l_s("invalid option"));
lua_pushstring(L, setlocale(cat[op], luaL_check_string(L, 1)));
return 1;
}
@@ -564,10 +564,10 @@ static int io_exit (lua_State *L) {
static int io_debug (lua_State *L) {
for (;;) {
- char buffer[250];
- fprintf(stderr, "lua_debug> ");
+ l_char buffer[250];
+ fprintf(stderr, l_s("lua_debug> "));
if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
- strcmp(buffer, "cont\n") == 0)
+ strcmp(buffer, l_s("cont\n")) == 0)
return 0;
lua_dostring(L, buffer);
lua_settop(L, 0); /* remove eventual returns */
@@ -584,61 +584,61 @@ static int errorfb (lua_State *L) {
lua_Debug ar;
luaL_Buffer b;
luaL_buffinit(L, &b);
- luaL_addstring(&b, "error: ");
+ luaL_addstring(&b, l_s("error: "));
luaL_addstring(&b, luaL_check_string(L, 1));
- luaL_addstring(&b, "\n");
+ luaL_addstring(&b, l_s("\n"));
while (lua_getstack(L, level++, &ar)) {
- char buff[120]; /* enough to fit following `sprintf's */
+ l_char buff[120]; /* enough to fit following `sprintf's */
if (level == 2)
- luaL_addstring(&b, "stack traceback:\n");
+ luaL_addstring(&b, l_s("stack traceback:\n"));
else if (level > LEVELS1 && firstpart) {
/* no more than `LEVELS2' more levels? */
if (!lua_getstack(L, level+LEVELS2, &ar))
level--; /* keep going */
else {
- luaL_addstring(&b, " ...\n"); /* too many levels */
+ luaL_addstring(&b, l_s(" ...\n")); /* too many levels */
while (lua_getstack(L, level+LEVELS2, &ar)) /* find last levels */
level++;
}
firstpart = 0;
continue;
}
- sprintf(buff, "%4d: ", level-1);
+ sprintf(buff, l_s("%4d: "), level-1);
luaL_addstring(&b, buff);
- lua_getinfo(L, "Snl", &ar);
+ lua_getinfo(L, l_s("Snl"), &ar);
switch (*ar.namewhat) {
- case 'g': case 'l': /* global, local */
- sprintf(buff, "function `%.50s'", ar.name);
+ case l_c('g'): case l_c('l'): /* global, local */
+ sprintf(buff, l_s("function `%.50s'"), ar.name);
break;
- case 'f': /* field */
- sprintf(buff, "method `%.50s'", ar.name);
+ case l_c('f'): /* field */
+ sprintf(buff, l_s("method `%.50s'"), ar.name);
break;
- case 't': /* tag method */
- sprintf(buff, "`%.50s' tag method", ar.name);
+ case l_c('t'): /* tag method */
+ sprintf(buff, l_s("`%.50s' tag method"), ar.name);
break;
default: {
- if (*ar.what == 'm') /* main? */
- sprintf(buff, "main of %.70s", ar.short_src);
- else if (*ar.what == 'C') /* C function? */
- sprintf(buff, "%.70s", ar.short_src);
+ if (*ar.what == l_c('m')) /* main? */
+ sprintf(buff, l_s("main of %.70s"), ar.short_src);
+ else if (*ar.what == l_c('C')) /* C function? */
+ sprintf(buff, l_s("%.70s"), ar.short_src);
else
- sprintf(buff, "function <%d:%.70s>", ar.linedefined, ar.short_src);
+ sprintf(buff, l_s("function <%d:%.70s>"), ar.linedefined, ar.short_src);
ar.source = NULL; /* do not print source again */
}
}
luaL_addstring(&b, buff);
if (ar.currentline > 0) {
- sprintf(buff, " at line %d", ar.currentline);
+ sprintf(buff, l_s(" at line %d"), ar.currentline);
luaL_addstring(&b, buff);
}
if (ar.source) {
- sprintf(buff, " [%.70s]", ar.short_src);
+ sprintf(buff, l_s(" [%.70s]"), ar.short_src);
luaL_addstring(&b, buff);
}
- luaL_addstring(&b, "\n");
+ luaL_addstring(&b, l_s("\n"));
}
luaL_pushresult(&b);
- lua_getglobal(L, LUA_ALERT);
+ lua_getglobal(L, l_s(LUA_ALERT));
if (lua_isfunction(L, -1)) { /* avoid loop if _ALERT is not defined */
lua_pushvalue(L, -2); /* error message */
lua_rawcall(L, 1, 0);
@@ -649,44 +649,44 @@ static int errorfb (lua_State *L) {
static const luaL_reg iolib[] = {
- {"appendto", io_appendto},
- {"clock", io_clock},
- {"closefile", io_close},
- {"date", io_date},
- {"debug", io_debug},
- {"difftime", io_difftime},
- {"execute", io_execute},
- {"exit", io_exit},
- {"flush", io_flush},
- {"getenv", io_getenv},
- {"openfile", io_open},
- {"read", io_read},
- {"readfrom", io_readfrom},
- {"remove", io_remove},
- {"rename", io_rename},
- {"seek", io_seek},
- {"setlocale", io_setloc},
- {"time", io_time},
- {"tmpfile", io_tmpfile},
- {"tmpname", io_tmpname},
- {"write", io_write},
- {"writeto", io_writeto},
- {LUA_ERRORMESSAGE, errorfb}
+ {l_s("appendto"), io_appendto},
+ {l_s("clock"), io_clock},
+ {l_s("closefile"), io_close},
+ {l_s("date"), io_date},
+ {l_s("debug"), io_debug},
+ {l_s("difftime"), io_difftime},
+ {l_s("execute"), io_execute},
+ {l_s("exit"), io_exit},
+ {l_s("flush"), io_flush},
+ {l_s("getenv"), io_getenv},
+ {l_s("openfile"), io_open},
+ {l_s("read"), io_read},
+ {l_s("readfrom"), io_readfrom},
+ {l_s("remove"), io_remove},
+ {l_s("rename"), io_rename},
+ {l_s("seek"), io_seek},
+ {l_s("setlocale"), io_setloc},
+ {l_s("time"), io_time},
+ {l_s("tmpfile"), io_tmpfile},
+ {l_s("tmpname"), io_tmpname},
+ {l_s("write"), io_write},
+ {l_s("writeto"), io_writeto},
+ {l_s(LUA_ERRORMESSAGE), errorfb}
};
LUALIB_API void lua_iolibopen (lua_State *L) {
int iotag = lua_newtype(L, FILEHANDLE, LUA_TUSERDATA);
- lua_newtype(L, "ClosedFileHandle", LUA_TUSERDATA);
+ lua_newtype(L, l_s("ClosedFileHandle"), LUA_TUSERDATA);
luaL_openl(L, iolib);
/* predefined file handles */
setfile(L, stdin, INFILE);
setfile(L, stdout, OUTFILE);
- setfilebyname(L, stdin, "_STDIN");
- setfilebyname(L, stdout, "_STDOUT");
- setfilebyname(L, stderr, "_STDERR");
+ setfilebyname(L, stdin, l_s("_STDIN"));
+ setfilebyname(L, stdout, l_s("_STDOUT"));
+ setfilebyname(L, stderr, l_s("_STDERR"));
/* close files when collected */
lua_pushcfunction(L, file_collect);
- lua_settagmethod(L, iotag, "gc");
+ lua_settagmethod(L, iotag, l_s("gc"));
}
diff --git a/llex.c b/llex.c
index 386ea316..0bbc43be 100644
--- a/llex.c
+++ b/llex.c
@@ -1,5 +1,5 @@
/*
-** $Id: llex.c,v 1.78 2001/02/22 17:15:18 roberto Exp roberto $
+** $Id: llex.c,v 1.79 2001/02/22 18:59:59 roberto Exp roberto $
** Lexical Analyzer
** See Copyright Notice in lua.h
*/
@@ -25,10 +25,13 @@
/* ORDER RESERVED */
-static const char *const token2string [] = {
- "and", "break", "do", "else", "elseif", "end", "for",
- "function", "if", "local", "nil", "not", "or", "repeat", "return", "then",
- "until", "while", "", "..", "...", "==", ">=", "<=", "~=", "", "", "<eof>"};
+static const l_char *const token2string [] = {
+ l_s("and"), l_s("break"), l_s("do"), l_s("else"), l_s("elseif"),
+ l_s("end"), l_s("for"), l_s("function"), l_s("if"), l_s("local"),
+ l_s("nil"), l_s("not"), l_s("or"), l_s("repeat"), l_s("return"),
+ l_s("then"), l_s("until"), l_s("while"), l_s(""), l_s(".."), l_s("..."),
+ l_s("=="), l_s(">="), l_s("<="), l_s("~="), l_s(""), l_s(""), l_s("<eof>")
+};
void luaX_init (lua_State *L) {
@@ -44,37 +47,38 @@ void luaX_init (lua_State *L) {
#define MAXSRC 80
-void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) {
+void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg) {
if (val > limit) {
- char buff[90];
- sprintf(buff, "too many %.40s (limit=%d)", msg, limit);
+ l_char buff[90];
+ sprintf(buff, l_s("too many %.40s (limit=%d)"), msg, limit);
luaX_error(ls, buff, ls->t.token);
}
}
-void luaX_syntaxerror (LexState *ls, const char *s, const char *token) {
- char buff[MAXSRC];
+void luaX_syntaxerror (LexState *ls, const l_char *s, const l_char *token) {
+ l_char buff[MAXSRC];
luaO_chunkid(buff, getstr(ls->source), sizeof(buff));
- luaO_verror(ls->L, "%.99s;\n last token read: `%.30s' at line %d in %.80s",
+ luaO_verror(ls->L,
+ l_s("%.99s;\n last token read: `%.30s' at line %d in %.80s"),
s, token, ls->linenumber, buff);
}
-void luaX_error (LexState *ls, const char *s, int token) {
- char buff[TOKEN_LEN];
+void luaX_error (LexState *ls, const l_char *s, int token) {
+ l_char buff[TOKEN_LEN];
luaX_token2str(token, buff);
- if (buff[0] == '\0')
+ if (buff[0] == l_c('\0'))
luaX_syntaxerror(ls, s, G(ls->L)->Mbuffer);
else
luaX_syntaxerror(ls, s, buff);
}
-void luaX_token2str (int token, char *s) {
+void luaX_token2str (int token, l_char *s) {
if (token < 256) {
- s[0] = (char)token;
- s[1] = '\0';
+ s[0] = (l_char)token;
+ s[1] = l_c('\0');
}
else
strcpy(s, token2string[token-FIRST_RESERVED]);
@@ -82,16 +86,16 @@ void luaX_token2str (int token, char *s) {
static void luaX_invalidchar (LexState *ls, int c) {
- char buff[8];
- sprintf(buff, "0x%02X", c);
- luaX_syntaxerror(ls, "invalid control char", buff);
+ l_char buff[8];
+ sprintf(buff, l_s("0x%02X"), c);
+ luaX_syntaxerror(ls, l_s("invalid control l_char"), buff);
}
static void inclinenumber (LexState *LS) {
next(LS); /* skip `\n' */
++LS->linenumber;
- luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk");
+ luaX_checklimit(LS, LS->linenumber, MAX_INT, l_s("lines in a chunk"));
}
@@ -104,10 +108,10 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
LS->lastline = 1;
LS->source = source;
next(LS); /* read first char */
- if (LS->current == '#') {
+ if (LS->current == l_c('#')) {
do { /* skip first line */
next(LS);
- } while (LS->current != '\n' && LS->current != EOZ);
+ } while (LS->current != l_c('\n') && LS->current != EOZ);
}
}
@@ -126,7 +130,7 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
#define checkbuffer(L, n, len) if ((len)+(n) > G(L)->Mbuffsize) \
luaO_openspace(L, (len)+(n)+EXTRABUFF)
-#define save(L, c, l) (G(L)->Mbuffer[l++] = (char)c)
+#define save(L, c, l) (G(L)->Mbuffer[l++] = (l_char)c)
#define save_and_next(L, LS, l) (save(L, LS->current, l), next(LS))
@@ -137,8 +141,8 @@ static size_t readname (LexState *LS) {
do {
checkbuffer(L, 10, l);
save_and_next(L, LS, l);
- } while (isalnum(LS->current) || LS->current == '_');
- save(L, '\0', l);
+ } while (isalnum(LS->current) || LS->current == l_c('_'));
+ save(L, l_c('\0'), l);
return l-1;
}
@@ -148,36 +152,37 @@ static void read_number (LexState *LS, int comma, SemInfo *seminfo) {
lua_State *L = LS->L;
size_t l = 0;
checkbuffer(L, 10, l);
- if (comma) save(L, '.', l);
+ if (comma) save(L, l_c('.'), l);
while (isdigit(LS->current)) {
checkbuffer(L, 10, l);
save_and_next(L, LS, l);
}
- if (LS->current == '.') {
+ if (LS->current == l_c('.')) {
save_and_next(L, LS, l);
- if (LS->current == '.') {
+ if (LS->current == l_c('.')) {
save_and_next(L, LS, l);
- save(L, '\0', l);
- luaX_error(LS, "ambiguous syntax"
- " (decimal point x string concatenation)", TK_NUMBER);
+ save(L, l_c('\0'), l);
+ luaX_error(LS,
+ l_s("ambiguous syntax (decimal point x string concatenation)"),
+ TK_NUMBER);
}
}
while (isdigit(LS->current)) {
checkbuffer(L, 10, l);
save_and_next(L, LS, l);
}
- if (LS->current == 'e' || LS->current == 'E') {
+ if (LS->current == l_c('e') || LS->current == l_c('E')) {
save_and_next(L, LS, l); /* read `E' */
- if (LS->current == '+' || LS->current == '-')
+ if (LS->current == l_c('+') || LS->current == l_c('-'))
save_and_next(L, LS, l); /* optional exponent sign */
while (isdigit(LS->current)) {
checkbuffer(L, 10, l);
save_and_next(L, LS, l);
}
}
- save(L, '\0', l);
+ save(L, l_c('\0'), l);
if (!luaO_str2d(G(L)->Mbuffer, &seminfo->r))
- luaX_error(LS, "malformed number", TK_NUMBER);
+ luaX_error(LS, l_s("malformed number"), TK_NUMBER);
}
@@ -186,32 +191,32 @@ static void read_long_string (LexState *LS, SemInfo *seminfo) {
int cont = 0;
size_t l = 0;
checkbuffer(L, 10, l);
- save(L, '[', l); /* save first `[' */
+ save(L, l_c('['), l); /* save first `[' */
save_and_next(L, LS, l); /* pass the second `[' */
for (;;) {
checkbuffer(L, 10, l);
switch (LS->current) {
case EOZ:
- save(L, '\0', l);
- luaX_error(LS, "unfinished long string", TK_STRING);
+ save(L, l_c('\0'), l);
+ luaX_error(LS, l_s("unfinished long string"), TK_STRING);
break; /* to avoid warnings */
- case '[':
+ case l_c('['):
save_and_next(L, LS, l);
- if (LS->current == '[') {
+ if (LS->current == l_c('[')) {
cont++;
save_and_next(L, LS, l);
}
continue;
- case ']':
+ case l_c(']'):
save_and_next(L, LS, l);
- if (LS->current == ']') {
+ if (LS->current == l_c(']')) {
if (cont == 0) goto endloop;
cont--;
save_and_next(L, LS, l);
}
continue;
- case '\n':
- save(L, '\n', l);
+ case l_c('\n'):
+ save(L, l_c('\n'), l);
inclinenumber(LS);
continue;
default:
@@ -219,7 +224,7 @@ static void read_long_string (LexState *LS, SemInfo *seminfo) {
}
} endloop:
save_and_next(L, LS, l); /* skip the second `]' */
- save(L, '\0', l);
+ save(L, l_c('\0'), l);
seminfo->ts = luaS_newlstr(L, G(L)->Mbuffer+2, l-5);
}
@@ -232,38 +237,38 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) {
while (LS->current != del) {
checkbuffer(L, 10, l);
switch (LS->current) {
- case EOZ: case '\n':
- save(L, '\0', l);
- luaX_error(LS, "unfinished string", TK_STRING);
+ case EOZ: case l_c('\n'):
+ save(L, l_c('\0'), l);
+ luaX_error(LS, l_s("unfinished string"), TK_STRING);
break; /* to avoid warnings */
- case '\\':
+ case l_c('\\'):
next(LS); /* do not save the `\' */
switch (LS->current) {
- case 'a': save(L, '\a', l); next(LS); break;
- case 'b': save(L, '\b', l); next(LS); break;
- case 'f': save(L, '\f', l); next(LS); break;
- case 'n': save(L, '\n', l); next(LS); break;
- case 'r': save(L, '\r', l); next(LS); break;
- case 't': save(L, '\t', l); next(LS); break;
- case 'v': save(L, '\v', l); next(LS); break;
- case '\n': save(L, '\n', l); inclinenumber(LS); break;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9': {
- int c = 0;
- int i = 0;
- do {
- c = 10*c + (LS->current-'0');
- next(LS);
- } while (++i<3 && isdigit(LS->current));
- if (c > UCHAR_MAX) {
- save(L, '\0', l);
- luaX_error(LS, "escape sequence too large", TK_STRING);
+ case l_c('a'): save(L, l_c('\a'), l); next(LS); break;
+ case l_c('b'): save(L, l_c('\b'), l); next(LS); break;
+ case l_c('f'): save(L, l_c('\f'), l); next(LS); break;
+ case l_c('n'): save(L, l_c('\n'), l); next(LS); break;
+ case l_c('r'): save(L, l_c('\r'), l); next(LS); break;
+ case l_c('t'): save(L, l_c('\t'), l); next(LS); break;
+ case l_c('v'): save(L, l_c('\v'), l); next(LS); break;
+ case l_c('\n'): save(L, l_c('\n'), l); inclinenumber(LS); break;
+ default: {
+ if (!isdigit(LS->current))
+ save_and_next(L, LS, l); /* handles \\, \", \', and \? */
+ else { /* \xxx */
+ int c = 0;
+ int i = 0;
+ do {
+ c = 10*c + (LS->current-l_c('0'));
+ next(LS);
+ } while (++i<3 && isdigit(LS->current));
+ if (c > UCHAR_MAX) {
+ save(L, l_c('\0'), l);
+ luaX_error(LS, l_s("escape sequence too large"), TK_STRING);
+ }
+ save(L, c, l);
}
- save(L, c, l);
- break;
}
- default: /* handles \\, \", \', and \? */
- save_and_next(L, LS, l);
}
break;
default:
@@ -271,7 +276,7 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) {
}
}
save_and_next(L, LS, l); /* skip delimiter */
- save(L, '\0', l);
+ save(L, l_c('\0'), l);
seminfo->ts = luaS_newlstr(L, G(L)->Mbuffer+1, l-3);
}
@@ -280,92 +285,85 @@ int luaX_lex (LexState *LS, SemInfo *seminfo) {
for (;;) {
switch (LS->current) {
- case ' ': case '\t': case '\r': /* `\r' to avoid problems with DOS */
+ case l_c(' '): case l_c('\t'): case l_c('\r'): /* `\r' to avoid problems with DOS */
next(LS);
continue;
- case '\n':
+ case l_c('\n'):
inclinenumber(LS);
continue;
- case '$':
- luaX_error(LS, "unexpected `$' (pragmas are no longer supported)", '$');
+ case l_c('$'):
+ luaX_error(LS,
+ l_s("unexpected `$' (pragmas are no longer supported)"),
+ LS->current);
break;
- case '-':
+ case l_c('-'):
next(LS);
- if (LS->current != '-') return '-';
- do { next(LS); } while (LS->current != '\n' && LS->current != EOZ);
+ if (LS->current != l_c('-')) return l_c('-');
+ do { next(LS); } while (LS->current != l_c('\n') && LS->current != EOZ);
continue;
- case '[':
+ case l_c('['):
next(LS);
- if (LS->current != '[') return '[';
+ if (LS->current != l_c('[')) return l_c('[');
else {
read_long_string(LS, seminfo);
return TK_STRING;
}
- case '=':
+ case l_c('='):
next(LS);
- if (LS->current != '=') return '=';
+ if (LS->current != l_c('=')) return l_c('=');
else { next(LS); return TK_EQ; }
- case '<':
+ case l_c('<'):
next(LS);
- if (LS->current != '=') return '<';
+ if (LS->current != l_c('=')) return l_c('<');
else { next(LS); return TK_LE; }
- case '>':
+ case l_c('>'):
next(LS);
- if (LS->current != '=') return '>';
+ if (LS->current != l_c('=')) return l_c('>');
else { next(LS); return TK_GE; }
- case '~':
+ case l_c('~'):
next(LS);
- if (LS->current != '=') return '~';
+ if (LS->current != l_c('=')) return l_c('~');
else { next(LS); return TK_NE; }
- case '"':
- case '\'':
+ case l_c('"'):
+ case l_c('\''):
read_string(LS, LS->current, seminfo);
return TK_STRING;
- case '.':
+ case l_c('.'):
next(LS);
- if (LS->current == '.') {
+ if (LS->current == l_c('.')) {
next(LS);
- if (LS->current == '.') {
+ if (LS->current == l_c('.')) {
next(LS);
return TK_DOTS; /* ... */
}
else return TK_CONCAT; /* .. */
}
- else if (!isdigit(LS->current)) return '.';
+ else if (!isdigit(LS->current)) return l_c('.');
else {
read_number(LS, 1, seminfo);
return TK_NUMBER;
}
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- read_number(LS, 0, seminfo);
- return TK_NUMBER;
-
case EOZ:
return TK_EOS;
- case '_': goto tname;
-
- default:
- if (!isalpha(LS->current)) {
- int c = LS->current;
- if (iscntrl(c))
- luaX_invalidchar(LS, c);
- next(LS);
- return c;
+ default: {
+ if (isdigit(LS->current)) {
+ read_number(LS, 0, seminfo);
+ return TK_NUMBER;
}
- tname: { /* identifier or reserved word */
+ else if (isalpha(LS->current) || LS->current == l_c('_')) {
+ /* identifier or reserved word */
size_t l = readname(LS);
TString *ts = luaS_newlstr(LS->L, G(LS->L)->Mbuffer, l);
if (ts->marked >= RESERVEDMARK) /* reserved word? */
@@ -373,6 +371,14 @@ int luaX_lex (LexState *LS, SemInfo *seminfo) {
seminfo->ts = ts;
return TK_NAME;
}
+ else {
+ int c = LS->current;
+ if (iscntrl(c))
+ luaX_invalidchar(LS, c);
+ next(LS);
+ return c; /* single-char tokens (+ - / ...) */
+ }
+ }
}
}
}
diff --git a/llex.h b/llex.h
index 07e0bf05..28b86ddb 100644
--- a/llex.h
+++ b/llex.h
@@ -1,5 +1,5 @@
/*
-** $Id: llex.h,v 1.32 2000/12/04 18:33:40 roberto Exp roberto $
+** $Id: llex.h,v 1.33 2001/01/10 16:40:56 roberto Exp roberto $
** Lexical Analyzer
** See Copyright Notice in lua.h
*/
@@ -14,7 +14,7 @@
#define FIRST_RESERVED 257
/* maximum length of a reserved word */
-#define TOKEN_LEN (sizeof("function"))
+#define TOKEN_LEN (sizeof(l_s("function")))
/*
@@ -63,10 +63,10 @@ typedef struct LexState {
void luaX_init (lua_State *L);
void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source);
int luaX_lex (LexState *LS, SemInfo *seminfo);
-void luaX_checklimit (LexState *ls, int val, int limit, const char *msg);
-void luaX_syntaxerror (LexState *ls, const char *s, const char *token);
-void luaX_error (LexState *ls, const char *s, int token);
-void luaX_token2str (int token, char *s);
+void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg);
+void luaX_syntaxerror (LexState *ls, const l_char *s, const l_char *token);
+void luaX_error (LexState *ls, const l_char *s, int token);
+void luaX_token2str (int token, l_char *s);
#endif
diff --git a/llimits.h b/llimits.h
index 2b0556a1..46b531f1 100644
--- a/llimits.h
+++ b/llimits.h
@@ -1,6 +1,6 @@
/*
-** $Id: llimits.h,v 1.23 2001/02/20 18:15:33 roberto Exp roberto $
-** Limits, basic types, and some other "installation-dependent" definitions
+** $Id: llimits.h,v 1.24 2001/02/22 17:15:18 roberto Exp roberto $
+** Limits, basic types, and some other `installation-dependent' definitions
** See Copyright Notice in lua.h
*/
@@ -33,7 +33,7 @@
/* function to convert a lua_Number to a string */
#ifndef NUMBER_FMT
-#define NUMBER_FMT "%.16g" /* LUA_NUMBER */
+#define NUMBER_FMT l_s("%.16g") /* LUA_NUMBER */
#endif
#ifndef lua_number2str
#define lua_number2str(s,n) sprintf((s), NUMBER_FMT, (n))
@@ -45,11 +45,21 @@
#endif
+/* macro to control type of literal strings */
+#ifndef l_s
+#define l_s(x) x
+#endif
+
+/* macro to control type of literal chars */
+#ifndef l_c
+#define l_c(x) x
+#endif
+
/*
** the following types define integer types for values that may not
-** fit in a "small int" (16 bits), but may waste space in a
-** "large long" (64 bits). The current definitions should work in
+** fit in a `small int' (16 bits), but may waste space in a
+** `large long' (64 bits). The current definitions should work in
** any machine, but may not be optimal.
*/
@@ -88,7 +98,7 @@ typedef unsigned char lu_byte;
-#define MINPOWER2 4 /* minimum size for "growing" vectors */
+#define MINPOWER2 4 /* minimum size for `growing' vectors */
diff --git a/lmathlib.c b/lmathlib.c
index b7fc41c6..4f6fb122 100644
--- a/lmathlib.c
+++ b/lmathlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lmathlib.c,v 1.34 2001/02/02 19:02:40 roberto Exp roberto $
+** $Id: lmathlib.c,v 1.35 2001/02/22 18:59:59 roberto Exp roberto $
** Standard mathematical library
** See Copyright Notice in lua.h
*/
@@ -176,18 +176,18 @@ static int math_random (lua_State *L) {
}
case 1: { /* only upper limit */
int u = luaL_check_int(L, 1);
- luaL_arg_check(L, 1<=u, 1, "interval is empty");
+ luaL_arg_check(L, 1<=u, 1, l_s("interval is empty"));
lua_pushnumber(L, (int)(r*u)+1); /* integer between 1 and `u' */
break;
}
case 2: { /* lower and upper limits */
int l = luaL_check_int(L, 1);
int u = luaL_check_int(L, 2);
- luaL_arg_check(L, l<=u, 2, "interval is empty");
+ luaL_arg_check(L, l<=u, 2, l_s("interval is empty"));
lua_pushnumber(L, (int)(r*(u-l+1))+l); /* integer between `l' and `u' */
break;
}
- default: lua_error(L, "wrong number of arguments");
+ default: lua_error(L, l_s("wrong number of arguments"));
}
return 1;
}
@@ -200,29 +200,29 @@ static int math_randomseed (lua_State *L) {
static const 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}
+{l_s("abs"), math_abs},
+{l_s("sin"), math_sin},
+{l_s("cos"), math_cos},
+{l_s("tan"), math_tan},
+{l_s("asin"), math_asin},
+{l_s("acos"), math_acos},
+{l_s("atan"), math_atan},
+{l_s("atan2"), math_atan2},
+{l_s("ceil"), math_ceil},
+{l_s("floor"), math_floor},
+{l_s("mod"), math_mod},
+{l_s("frexp"), math_frexp},
+{l_s("ldexp"), math_ldexp},
+{l_s("sqrt"), math_sqrt},
+{l_s("min"), math_min},
+{l_s("max"), math_max},
+{l_s("log"), math_log},
+{l_s("log10"), math_log10},
+{l_s("exp"), math_exp},
+{l_s("deg"), math_deg},
+{l_s("rad"), math_rad},
+{l_s("random"), math_random},
+{l_s("randomseed"), math_randomseed}
};
/*
@@ -231,8 +231,8 @@ static const luaL_reg mathlib[] = {
LUALIB_API void lua_mathlibopen (lua_State *L) {
luaL_openl(L, mathlib);
lua_pushcfunction(L, math_pow);
- lua_settagmethod(L, LUA_TNUMBER, "pow");
+ lua_settagmethod(L, LUA_TNUMBER, l_s("pow"));
lua_pushnumber(L, PI);
- lua_setglobal(L, "PI");
+ lua_setglobal(L, l_s("PI"));
}
diff --git a/lmem.c b/lmem.c
index cfbe74d5..f88e769e 100644
--- a/lmem.c
+++ b/lmem.c
@@ -1,5 +1,5 @@
/*
-** $Id: lmem.c,v 1.46 2001/02/06 16:01:29 roberto Exp roberto $
+** $Id: lmem.c,v 1.47 2001/02/20 18:15:33 roberto Exp roberto $
** Interface to Memory Manager
** See Copyright Notice in lua.h
*/
@@ -23,7 +23,7 @@
void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
- int limit, const char *errormsg) {
+ int limit, const l_char *errormsg) {
void *newblock;
int newsize = (*size)*2;
if (newsize < MINPOWER2)
@@ -49,7 +49,7 @@ void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) {
block = NULL;
}
else if (size >= MAX_SIZET)
- luaD_error(L, "memory allocation error: block too big");
+ luaD_error(L, l_s("memory allocation error: block too big"));
else {
block = l_realloc(block, oldsize, size);
if (block == NULL) {
diff --git a/lmem.h b/lmem.h
index 3dca8871..bf1d6836 100644
--- a/lmem.h
+++ b/lmem.h
@@ -1,5 +1,5 @@
/*
-** $Id: lmem.h,v 1.20 2001/02/02 15:13:05 roberto Exp roberto $
+** $Id: lmem.h,v 1.21 2001/02/20 18:15:33 roberto Exp roberto $
** Interface to Memory Manager
** See Copyright Notice in lua.h
*/
@@ -16,7 +16,7 @@
void *luaM_realloc (lua_State *L, void *oldblock, lu_mem oldsize, lu_mem size);
void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem,
- int limit, const char *errormsg);
+ int limit, const l_char *errormsg);
#define luaM_free(L, b, s) luaM_realloc(L, (b), (s), 0)
#define luaM_freelem(L, b, t) luaM_realloc(L, (b), sizeof(t), 0)
diff --git a/lobject.c b/lobject.c
index 9292f053..c66a3b02 100644
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
/*
-** $Id: lobject.c,v 1.65 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lobject.c,v 1.66 2001/02/22 17:15:18 roberto Exp roberto $
** Some generic functions over Lua objects
** See Copyright Notice in lua.h
*/
@@ -35,21 +35,21 @@ int luaO_equalObj (const TObject *t1, const TObject *t2) {
}
-char *luaO_openspace (lua_State *L, size_t n) {
+l_char *luaO_openspace (lua_State *L, size_t n) {
if (n > G(L)->Mbuffsize) {
- luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, n, char);
+ luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, n, l_char);
G(L)->Mbuffsize = n;
}
return G(L)->Mbuffer;
}
-int luaO_str2d (const char *s, lua_Number *result) { /* LUA_NUMBER */
- char *endptr;
+int luaO_str2d (const l_char *s, lua_Number *result) { /* LUA_NUMBER */
+ l_char *endptr;
lua_Number res = lua_str2number(s, &endptr);
if (endptr == s) return 0; /* no conversion */
while (isspace(uchar(*endptr))) endptr++;
- if (*endptr != '\0') return 0; /* invalid trailing characters? */
+ if (*endptr != l_c('\0')) return 0; /* invalid trailing characters? */
*result = res;
return 1;
}
@@ -59,9 +59,9 @@ int luaO_str2d (const char *s, lua_Number *result) { /* LUA_NUMBER */
#define MAX_VERROR 280
/* this function needs to handle only '%d' and '%.XXs' formats */
-void luaO_verror (lua_State *L, const char *fmt, ...) {
+void luaO_verror (lua_State *L, const l_char *fmt, ...) {
va_list argp;
- char buff[MAX_VERROR]; /* to hold formatted message */
+ l_char buff[MAX_VERROR]; /* to hold formatted message */
va_start(argp, fmt);
vsprintf(buff, fmt, argp);
va_end(argp);
@@ -69,36 +69,36 @@ void luaO_verror (lua_State *L, const char *fmt, ...) {
}
-void luaO_chunkid (char *out, const char *source, int bufflen) {
- if (*source == '=') {
+void luaO_chunkid (l_char *out, const l_char *source, int bufflen) {
+ if (*source == l_c('=')) {
strncpy(out, source+1, bufflen); /* remove first char */
- out[bufflen-1] = '\0'; /* ensures null termination */
+ out[bufflen-1] = l_c('\0'); /* ensures null termination */
}
else {
- if (*source == '@') {
+ if (*source == l_c('@')) {
int l;
source++; /* skip the `@' */
- bufflen -= sizeof("file `...%s'");
+ bufflen -= sizeof(l_s("file `...%s'"));
l = strlen(source);
if (l>bufflen) {
source += (l-bufflen); /* get last part of file name */
- sprintf(out, "file `...%.99s'", source);
+ sprintf(out, l_s("file `...%.99s'"), source);
}
else
- sprintf(out, "file `%.99s'", source);
+ sprintf(out, l_s("file `%.99s'"), source);
}
else {
- int len = strcspn(source, "\n"); /* stop at first newline */
- bufflen -= sizeof("string \"%.*s...\"");
+ int len = strcspn(source, l_s("\n")); /* stop at first newline */
+ bufflen -= sizeof(l_s("string \"%.*s...\""));
if (len > bufflen) len = bufflen;
- if (source[len] != '\0') { /* must truncate? */
- strcpy(out, "string \"");
+ if (source[len] != l_c('\0')) { /* must truncate? */
+ strcpy(out, l_s("string \""));
out += strlen(out);
strncpy(out, source, len);
- strcpy(out+len, "...\"");
+ strcpy(out+len, l_s("...\""));
}
else
- sprintf(out, "string \"%.99s\"", source);
+ sprintf(out, l_s("string \"%.99s\""), source);
}
}
}
diff --git a/lobject.h b/lobject.h
index 74f3c616..245a5d29 100644
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
/*
-** $Id: lobject.h,v 1.96 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lobject.h,v 1.97 2001/02/20 18:28:11 roberto Exp roberto $
** Type definitions for Lua objects
** See Copyright Notice in lua.h
*/
@@ -117,7 +117,7 @@ union L_UTString {
-#define getstr(ts) ((char *)(ts) + sizeof(union L_UTString))
+#define getstr(ts) ((l_char *)(ts) + sizeof(union L_UTString))
#define svalue(o) getstr(tsvalue(o))
@@ -200,7 +200,7 @@ typedef struct Hash {
/*
-** "module" operation for hashing (size is always a power of 2)
+** `module' operation for hashing (size is always a power of 2)
*/
#define lmod(s,size) ((int)((s) & ((size)-1)))
@@ -220,13 +220,13 @@ typedef struct CallInfo {
extern const TObject luaO_nilobject;
-char *luaO_openspace (lua_State *L, size_t n);
+l_char *luaO_openspace (lua_State *L, size_t n);
int luaO_equalObj (const TObject *t1, const TObject *t2);
-int luaO_str2d (const char *s, lua_Number *result);
+int luaO_str2d (const l_char *s, lua_Number *result);
-void luaO_verror (lua_State *L, const char *fmt, ...);
-void luaO_chunkid (char *out, const char *source, int len);
+void luaO_verror (lua_State *L, const l_char *fmt, ...);
+void luaO_chunkid (l_char *out, const l_char *source, int len);
#endif
diff --git a/lparser.c b/lparser.c
index bb4ea097..53e05565 100644
--- a/lparser.c
+++ b/lparser.c
@@ -1,5 +1,5 @@
/*
-** $Id: lparser.c,v 1.137 2001/02/22 18:59:59 roberto Exp roberto $
+** $Id: lparser.c,v 1.138 2001/02/23 13:38:56 roberto Exp roberto $
** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h
*/
@@ -72,9 +72,9 @@ static void lookahead (LexState *ls) {
static void error_expected (LexState *ls, int token) {
- char buff[30], t[TOKEN_LEN];
+ l_char buff[30], t[TOKEN_LEN];
luaX_token2str(token, t);
- sprintf(buff, "`%.10s' expected", t);
+ sprintf(buff, l_s("`%.10s' expected"), t);
luaK_error(ls, buff);
}
@@ -86,7 +86,7 @@ static void check (LexState *ls, int c) {
}
-static void check_condition (LexState *ls, int c, const char *msg) {
+static void check_condition (LexState *ls, int c, const l_char *msg) {
if (!c) luaK_error(ls, msg);
}
@@ -105,11 +105,11 @@ static void check_match (LexState *ls, int what, int who, int where) {
if (where == ls->linenumber)
error_expected(ls, what);
else {
- char buff[70];
- char t_what[TOKEN_LEN], t_who[TOKEN_LEN];
+ l_char buff[70];
+ l_char t_what[TOKEN_LEN], t_who[TOKEN_LEN];
luaX_token2str(what, t_what);
luaX_token2str(who, t_who);
- sprintf(buff, "`%.10s' expected (to close `%.10s' at line %d)",
+ sprintf(buff, l_s("`%.10s' expected (to close `%.10s' at line %d)"),
t_what, t_who, where);
luaK_error(ls, buff);
}
@@ -123,7 +123,7 @@ static int string_constant (FuncState *fs, TString *s) {
int c = s->u.s.constindex;
if (c >= fs->nkstr || f->kstr[c] != s) {
luaM_growvector(fs->L, f->kstr, fs->nkstr, f->sizekstr, TString *,
- MAXARG_U, "constant table overflow");
+ MAXARG_U, l_s("constant table overflow"));
c = fs->nkstr++;
f->kstr[c] = s;
s->u.s.constindex = c; /* hint for next time */
@@ -139,7 +139,7 @@ static void code_string (LexState *ls, TString *s) {
static TString *str_checkname (LexState *ls) {
TString *ts;
- check_condition(ls, (ls->t.token == TK_NAME), "<name> expected");
+ check_condition(ls, (ls->t.token == TK_NAME), l_s("<name> expected"));
ts = ls->t.seminfo.ts;
next(ls);
return ts;
@@ -155,7 +155,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) {
FuncState *fs = ls->fs;
Proto *f = fs->f;
luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
- LocVar, MAX_INT, "");
+ LocVar, MAX_INT, l_s(""));
f->locvars[fs->nlocvars].varname = varname;
return fs->nlocvars++;
}
@@ -163,7 +163,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) {
static void new_localvar (LexState *ls, TString *name, int n) {
FuncState *fs = ls->fs;
- luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, "local variables");
+ luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, l_s("local variables"));
fs->actloc[fs->nactloc+n] = luaI_registerlocalvar(ls, name);
}
@@ -182,7 +182,7 @@ static void removelocalvars (LexState *ls, int nvars) {
}
-static void new_localvarstr (LexState *ls, const char *name, int n) {
+static void new_localvarstr (LexState *ls, const l_char *name, int n) {
new_localvar(ls, luaS_new(ls->L, name), n);
}
@@ -209,7 +209,7 @@ static int search_local (LexState *ls, TString *n, expdesc *var) {
static void singlevar (LexState *ls, TString *n, expdesc *var) {
int level = search_local(ls, n, var);
if (level >= 1) /* neither local (0) nor global (-1)? */
- luaX_syntaxerror(ls, "cannot access a variable in outer function",
+ luaX_syntaxerror(ls, l_s("cannot access a variable in outer function"),
getstr(n));
else if (level == -1) /* global? */
var->u.index = string_constant(ls->fs, n);
@@ -224,7 +224,7 @@ static int indexupvalue (LexState *ls, expdesc *v) {
return i;
}
/* new one */
- luaX_checklimit(ls, fs->f->nupvalues+1, MAXUPVALUES, "upvalues");
+ luaX_checklimit(ls, fs->f->nupvalues+1, MAXUPVALUES, l_s("upvalues"));
fs->upvalues[fs->f->nupvalues] = *v;
return fs->f->nupvalues++;
}
@@ -236,12 +236,12 @@ static void pushupvalue (LexState *ls, TString *n) {
int level = search_local(ls, n, &v);
if (level == -1) { /* global? */
if (fs->prev == NULL)
- luaX_syntaxerror(ls, "cannot access an upvalue at top level", getstr(n));
+ luaX_syntaxerror(ls, l_s("cannot access an upvalue at top level"), getstr(n));
v.u.index = string_constant(fs->prev, n);
}
else if (level != 1) {
luaX_syntaxerror(ls,
- "upvalue must be global or local to immediately outer function", getstr(n));
+ l_s("upvalue must be global or local to immediately outer function"), getstr(n));
}
luaK_code1(fs, OP_PUSHUPVALUE, indexupvalue(ls, &v));
}
@@ -267,11 +267,11 @@ static void adjust_mult_assign (LexState *ls, int nvars, int nexps) {
static void code_params (LexState *ls, int nparams, short dots) {
FuncState *fs = ls->fs;
adjustlocalvars(ls, nparams);
- luaX_checklimit(ls, fs->nactloc, MAXPARAMS, "parameters");
+ luaX_checklimit(ls, fs->nactloc, MAXPARAMS, l_s("parameters"));
fs->f->numparams = (short)fs->nactloc; /* `self' could be there already */
fs->f->is_vararg = dots;
if (dots) {
- new_localvarstr(ls, "arg", 0);
+ new_localvarstr(ls, l_s("arg"), 0);
adjustlocalvars(ls, 1);
}
luaK_deltastack(fs, fs->nactloc); /* count parameters in the stack */
@@ -300,7 +300,7 @@ static void pushclosure (LexState *ls, FuncState *func) {
for (i=0; i<func->f->nupvalues; i++)
luaK_tostack(ls, &func->upvalues[i], 1);
luaM_growvector(ls->L, f->kproto, fs->nkproto, f->sizekproto, Proto *,
- MAXARG_A, "constant table overflow");
+ MAXARG_A, l_s("constant table overflow"));
f->kproto[fs->nkproto++] = func->f;
luaK_code2(fs, OP_CLOSURE, fs->nkproto-1, func->f->nupvalues);
}
@@ -366,7 +366,7 @@ Proto *luaY_parser (lua_State *L, ZIO *z) {
open_func(&lexstate, &funcstate);
next(&lexstate); /* read first token */
chunk(&lexstate);
- check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
+ check_condition(&lexstate, (lexstate.t.token == TK_EOS), l_s("<eof> expected"));
close_func(&lexstate);
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.f->nupvalues == 0);
@@ -385,7 +385,7 @@ static int explist1 (LexState *ls) {
int n = 1; /* at least one expression */
expdesc v;
expr(ls, &v);
- while (ls->t.token == ',') {
+ while (ls->t.token == l_c(',')) {
next(ls); /* skip comma */
luaK_tostack(ls, &v, 1); /* gets only 1 value from previous expression */
expr(ls, &v);
@@ -400,13 +400,13 @@ static void funcargs (LexState *ls, int slf) {
FuncState *fs = ls->fs;
int slevel = fs->stacklevel - slf - 1; /* where is func in the stack */
switch (ls->t.token) {
- case '(': { /* funcargs -> `(' [ explist1 ] `)' */
+ case l_c('('): { /* funcargs -> `(' [ explist1 ] `)' */
int line = ls->linenumber;
int nargs = 0;
next(ls);
- if (ls->t.token != ')') /* arg list not empty? */
+ if (ls->t.token != l_c(')')) /* arg list not empty? */
nargs = explist1(ls);
- check_match(ls, ')', '(', line);
+ check_match(ls, l_c(')'), l_c('('), line);
#ifdef LUA_COMPAT_ARGRET
if (nargs > 0) /* arg list is not empty? */
luaK_setcallreturns(fs, 1); /* last call returns only 1 value */
@@ -415,7 +415,7 @@ static void funcargs (LexState *ls, int slf) {
#endif
break;
}
- case '{': { /* funcargs -> constructor */
+ case l_c('{'): { /* funcargs -> constructor */
constructor(ls);
break;
}
@@ -425,7 +425,7 @@ static void funcargs (LexState *ls, int slf) {
break;
}
default: {
- luaK_error(ls, "function arguments expected");
+ luaK_error(ls, l_s("function arguments expected"));
break;
}
}
@@ -448,15 +448,15 @@ static void recfield (LexState *ls) {
luaK_kstr(ls, checkname(ls));
break;
}
- case '[': {
+ case l_c('['): {
next(ls);
exp1(ls);
- check(ls, ']');
+ check(ls, l_c(']'));
break;
}
- default: luaK_error(ls, "<name> or `[' expected");
+ default: luaK_error(ls, l_s("<name> or `[' expected"));
}
- check(ls, '=');
+ check(ls, l_c('='));
exp1(ls);
}
@@ -466,9 +466,9 @@ static int recfields (LexState *ls) {
FuncState *fs = ls->fs;
int n = 1; /* at least one element */
recfield(ls);
- while (ls->t.token == ',') {
+ while (ls->t.token == l_c(',')) {
next(ls);
- if (ls->t.token == ';' || ls->t.token == '}')
+ if (ls->t.token == l_c(';') || ls->t.token == l_c('}'))
break;
recfield(ls);
n++;
@@ -485,14 +485,14 @@ static int listfields (LexState *ls) {
FuncState *fs = ls->fs;
int n = 1; /* at least one element */
exp1(ls);
- while (ls->t.token == ',') {
+ while (ls->t.token == l_c(',')) {
next(ls);
- if (ls->t.token == ';' || ls->t.token == '}')
+ if (ls->t.token == l_c(';') || ls->t.token == l_c('}'))
break;
exp1(ls);
n++;
luaX_checklimit(ls, n/LFIELDS_PER_FLUSH, MAXARG_A,
- "`item groups' in a list initializer");
+ l_s("`item groups' in a list initializer"));
if (n%LFIELDS_PER_FLUSH == 0)
luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH);
}
@@ -504,18 +504,18 @@ static int listfields (LexState *ls) {
static void constructor_part (LexState *ls, Constdesc *cd) {
switch (ls->t.token) {
- case ';': case '}': { /* constructor_part -> empty */
+ case l_c(';'): case l_c('}'): { /* constructor_part -> empty */
cd->n = 0;
cd->k = ls->t.token;
break;
}
case TK_NAME: { /* may be listfields or recfields */
lookahead(ls);
- if (ls->lookahead.token != '=') /* expression? */
+ if (ls->lookahead.token != l_c('=')) /* expression? */
goto case_default;
/* else go through to recfields */
}
- case '[': { /* constructor_part -> recfields */
+ case l_c('['): { /* constructor_part -> recfields */
cd->n = recfields(ls);
cd->k = 1; /* record */
break;
@@ -537,17 +537,17 @@ static void constructor (LexState *ls) {
int pc = luaK_code1(fs, OP_CREATETABLE, 0);
int nelems;
Constdesc cd;
- check(ls, '{');
+ check(ls, l_c('{'));
constructor_part(ls, &cd);
nelems = cd.n;
- if (optional(ls, ';')) {
+ if (optional(ls, l_c(';'))) {
Constdesc other_cd;
constructor_part(ls, &other_cd);
- check_condition(ls, (cd.k != other_cd.k), "invalid constructor syntax");
+ check_condition(ls, (cd.k != other_cd.k), l_s("invalid constructor syntax"));
nelems += other_cd.n;
}
- check_match(ls, '}', '{', line);
- luaX_checklimit(ls, nelems, MAXARG_U, "elements in a table constructor");
+ check_match(ls, l_c('}'), l_c('{'), line);
+ luaX_checklimit(ls, nelems, MAXARG_U, l_s("elements in a table constructor"));
SETARG_U(fs->f->code[pc], nelems); /* set initial table size */
}
@@ -581,7 +581,7 @@ static void primaryexp (LexState *ls, expdesc *v) {
next(ls);
break;
}
- case '{': { /* constructor */
+ case l_c('{'): { /* constructor */
constructor(ls);
break;
}
@@ -590,23 +590,23 @@ static void primaryexp (LexState *ls, expdesc *v) {
body(ls, 0, ls->linenumber);
break;
}
- case '(': {
+ case l_c('('): {
next(ls);
expr(ls, v);
- check(ls, ')');
+ check(ls, l_c(')'));
return;
}
case TK_NAME: {
singlevar(ls, str_checkname(ls), v);
return;
}
- case '%': {
+ case l_c('%'): {
next(ls); /* skip `%' */
pushupvalue(ls, str_checkname(ls));
break;
}
default: {
- luaK_error(ls, "unexpected symbol");
+ luaK_error(ls, l_s("unexpected symbol"));
return;
}
}
@@ -621,22 +621,22 @@ static void simpleexp (LexState *ls, expdesc *v) {
primaryexp(ls, v);
for (;;) {
switch (ls->t.token) {
- case '.': { /* `.' NAME */
+ case l_c('.'): { /* `.' NAME */
next(ls);
luaK_tostack(ls, v, 1); /* `v' must be on stack */
luaK_kstr(ls, checkname(ls));
v->k = VINDEXED;
break;
}
- case '[': { /* `[' exp1 `]' */
+ case l_c('['): { /* `[' exp1 `]' */
next(ls);
luaK_tostack(ls, v, 1); /* `v' must be on stack */
v->k = VINDEXED;
exp1(ls);
- check(ls, ']');
+ check(ls, l_c(']'));
break;
}
- case ':': { /* `:' NAME funcargs */
+ case l_c(':'): { /* `:' NAME funcargs */
next(ls);
luaK_tostack(ls, v, 1); /* `v' must be on stack */
luaK_code1(ls->fs, OP_PUSHSELF, checkname(ls));
@@ -645,7 +645,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
v->u.l.t = v->u.l.f = NO_JUMP;
break;
}
- case '(': case TK_STRING: case '{': { /* funcargs */
+ case l_c('('): case TK_STRING: case l_c('{'): { /* funcargs */
luaK_tostack(ls, v, 1); /* `v' must be on stack */
funcargs(ls, 0);
v->k = VEXP;
@@ -661,7 +661,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
static UnOpr getunopr (int op) {
switch (op) {
case TK_NOT: return OPR_NOT;
- case '-': return OPR_MINUS;
+ case l_c('-'): return OPR_MINUS;
default: return OPR_NOUNOPR;
}
}
@@ -669,17 +669,17 @@ static UnOpr getunopr (int op) {
static BinOpr getbinopr (int op) {
switch (op) {
- case '+': return OPR_ADD;
- case '-': return OPR_SUB;
- case '*': return OPR_MULT;
- case '/': return OPR_DIV;
- case '^': return OPR_POW;
+ case l_c('+'): return OPR_ADD;
+ case l_c('-'): return OPR_SUB;
+ case l_c('*'): return OPR_MULT;
+ case l_c('/'): return OPR_DIV;
+ case l_c('^'): return OPR_POW;
case TK_CONCAT: return OPR_CONCAT;
case TK_NE: return OPR_NE;
case TK_EQ: return OPR_EQ;
- case '<': return OPR_LT;
+ case l_c('<'): return OPR_LT;
case TK_LE: return OPR_LE;
- case '>': return OPR_GT;
+ case l_c('>'): return OPR_GT;
case TK_GE: return OPR_GE;
case TK_AND: return OPR_AND;
case TK_OR: return OPR_OR;
@@ -774,17 +774,17 @@ static void block (LexState *ls) {
static int assignment (LexState *ls, expdesc *v, int nvars) {
int left = 0; /* number of values left in the stack after assignment */
- luaX_checklimit(ls, nvars, MAXVARSLH, "variables in a multiple assignment");
- if (ls->t.token == ',') { /* assignment -> `,' simpleexp assignment */
+ luaX_checklimit(ls, nvars, MAXVARSLH, l_s("variables in a multiple assignment"));
+ if (ls->t.token == l_c(',')) { /* assignment -> `,' simpleexp assignment */
expdesc nv;
next(ls);
simpleexp(ls, &nv);
- check_condition(ls, (nv.k != VEXP), "syntax error");
+ check_condition(ls, (nv.k != VEXP), l_s("syntax error"));
left = assignment(ls, &nv, nvars+1);
}
else { /* assignment -> `=' explist1 */
int nexps;
- check(ls, '=');
+ check(ls, l_c('='));
nexps = explist1(ls);
adjust_mult_assign(ls, nvars, nexps);
}
@@ -856,17 +856,17 @@ static void forbody (LexState *ls, int nvar, OpCode prepfor, OpCode loopfor) {
static void fornum (LexState *ls, TString *varname) {
/* fornum -> NAME = exp1,exp1[,exp1] forbody */
FuncState *fs = ls->fs;
- check(ls, '=');
+ check(ls, l_c('='));
exp1(ls); /* initial value */
- check(ls, ',');
+ check(ls, l_c(','));
exp1(ls); /* limit */
- if (optional(ls, ','))
+ if (optional(ls, l_c(',')))
exp1(ls); /* optional step */
else
luaK_code1(fs, OP_PUSHINT, 1); /* default step */
new_localvar(ls, varname, 0);
- new_localvarstr(ls, "(limit)", 1);
- new_localvarstr(ls, "(step)", 2);
+ new_localvarstr(ls, l_s("(limit)"), 1);
+ new_localvarstr(ls, l_s("(step)"), 2);
forbody(ls, 3, OP_FORPREP, OP_FORLOOP);
}
@@ -874,17 +874,17 @@ static void fornum (LexState *ls, TString *varname) {
static void forlist (LexState *ls, TString *indexname) {
/* forlist -> NAME,NAME IN exp1 forbody */
TString *valname;
- check(ls, ',');
+ check(ls, l_c(','));
valname = str_checkname(ls);
/* next test is dirty, but avoids `in' being a reserved word */
check_condition(ls,
(ls->t.token == TK_NAME &&
- ls->t.seminfo.ts == luaS_newliteral(ls->L, "in")),
- "`in' expected");
+ ls->t.seminfo.ts == luaS_newliteral(ls->L, l_s("in"))),
+ l_s("`in' expected"));
next(ls); /* skip `in' */
exp1(ls); /* table */
- new_localvarstr(ls, "(table)", 0);
- new_localvarstr(ls, "(index)", 1);
+ new_localvarstr(ls, l_s("(table)"), 0);
+ new_localvarstr(ls, l_s("(index)"), 1);
new_localvar(ls, indexname, 2);
new_localvar(ls, valname, 3);
forbody(ls, 4, OP_LFORPREP, OP_LFORLOOP);
@@ -900,9 +900,9 @@ static void forstat (LexState *ls, int line) {
next(ls); /* skip `for' */
varname = str_checkname(ls); /* first variable name */
switch (ls->t.token) {
- case '=': fornum(ls, varname); break;
- case ',': forlist(ls, varname); break;
- default: luaK_error(ls, "`=' or `,' expected");
+ case l_c('='): fornum(ls, varname); break;
+ case l_c(','): forlist(ls, varname); break;
+ default: luaK_error(ls, l_s("`=' or `,' expected"));
}
check_match(ls, TK_END, TK_FOR, line);
leavebreak(fs, &bl);
@@ -949,8 +949,8 @@ static void localstat (LexState *ls) {
do {
next(ls); /* skip LOCAL or `,' */
new_localvar(ls, str_checkname(ls), nvars++);
- } while (ls->t.token == ',');
- if (optional(ls, '='))
+ } while (ls->t.token == l_c(','));
+ if (optional(ls, l_c('=')))
nexps = explist1(ls);
else
nexps = 0;
@@ -963,13 +963,13 @@ static int funcname (LexState *ls, expdesc *v) {
/* funcname -> NAME {`.' NAME} [`:' NAME] */
int needself = 0;
singlevar(ls, str_checkname(ls), v);
- while (ls->t.token == '.') {
+ while (ls->t.token == l_c('.')) {
next(ls);
luaK_tostack(ls, v, 1);
luaK_kstr(ls, checkname(ls));
v->k = VINDEXED;
}
- if (ls->t.token == ':') {
+ if (ls->t.token == l_c(':')) {
needself = 1;
next(ls);
luaK_tostack(ls, v, 1);
@@ -997,7 +997,7 @@ static void namestat (LexState *ls) {
expdesc v;
simpleexp(ls, &v);
if (v.k == VEXP) { /* stat -> func */
- check_condition(ls, luaK_lastisopen(fs), "syntax error"); /* an upvalue? */
+ check_condition(ls, luaK_lastisopen(fs), l_s("syntax error")); /* an upvalue? */
luaK_setcallreturns(fs, 0); /* call statement uses no results */
}
else { /* stat -> assignment */
@@ -1011,7 +1011,7 @@ static void retstat (LexState *ls) {
/* stat -> RETURN explist */
FuncState *fs = ls->fs;
next(ls); /* skip RETURN */
- if (!block_follow(ls->t.token) && ls->t.token != ';')
+ if (!block_follow(ls->t.token) && ls->t.token != l_c(';'))
explist1(ls); /* optional return values */
luaK_code1(fs, OP_RETURN, ls->fs->nactloc);
fs->stacklevel = fs->nactloc; /* removes all temp values */
@@ -1024,7 +1024,7 @@ static void breakstat (LexState *ls) {
int currentlevel = fs->stacklevel;
Breaklabel *bl = fs->bl;
if (!bl)
- luaK_error(ls, "no loop to break");
+ luaK_error(ls, l_s("no loop to break"));
next(ls); /* skip BREAK */
luaK_adjuststack(fs, currentlevel - bl->stacklevel);
luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
@@ -1086,14 +1086,14 @@ static void parlist (LexState *ls) {
/* parlist -> [ param { `,' param } ] */
int nparams = 0;
short dots = 0;
- if (ls->t.token != ')') { /* is `parlist' not empty? */
+ if (ls->t.token != l_c(')')) { /* is `parlist' not empty? */
do {
switch (ls->t.token) {
case TK_DOTS: next(ls); dots = 1; break;
case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break;
- default: luaK_error(ls, "<name> or `...' expected");
+ default: luaK_error(ls, l_s("<name> or `...' expected"));
}
- } while (!dots && optional(ls, ','));
+ } while (!dots && optional(ls, l_c(',')));
}
code_params(ls, nparams, dots);
}
@@ -1104,13 +1104,13 @@ static void body (LexState *ls, int needself, int line) {
FuncState new_fs;
open_func(ls, &new_fs);
new_fs.f->lineDefined = line;
- check(ls, '(');
+ check(ls, l_c('('));
if (needself) {
- new_localvarstr(ls, "self", 0);
+ new_localvarstr(ls, l_s("self"), 0);
adjustlocalvars(ls, 1);
}
parlist(ls);
- check(ls, ')');
+ check(ls, l_c(')'));
chunk(ls);
check_match(ls, TK_END, TK_FUNCTION, line);
close_func(ls);
@@ -1126,7 +1126,7 @@ static void chunk (LexState *ls) {
int islast = 0;
while (!islast && !block_follow(ls->t.token)) {
islast = statement(ls);
- optional(ls, ';');
+ optional(ls, l_c(';'));
lua_assert(ls->fs->stacklevel == ls->fs->nactloc);
}
}
diff --git a/lstate.c b/lstate.c
index 9fb89a8d..7e53c5a2 100644
--- a/lstate.c
+++ b/lstate.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstate.c,v 1.55 2001/01/26 11:45:51 roberto Exp roberto $
+** $Id: lstate.c,v 1.56 2001/02/02 15:13:05 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@@ -131,7 +131,7 @@ static void close_state (lua_State *L, lua_State *OL) {
luaS_freeall(L);
luaM_freearray(L, G(L)->TMtable, G(L)->sizeTM, struct TM);
luaM_freearray(L, G(L)->refArray, G(L)->sizeref, struct Ref);
- luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, char);
+ luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, l_char);
luaM_freelem(NULL, L->G, global_State);
}
luaM_freearray(OL, L->stack, L->stacksize, TObject);
diff --git a/lstate.h b/lstate.h
index f718d857..a6f0e062 100644
--- a/lstate.h
+++ b/lstate.h
@@ -1,5 +1,5 @@
/*
-** $Id: lstate.h,v 1.50 2001/02/02 15:13:05 roberto Exp roberto $
+** $Id: lstate.h,v 1.51 2001/02/20 18:15:33 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@@ -61,10 +61,10 @@ typedef struct stringtable {
/*
-** "global state", shared by all threads of this state
+** `global state', shared by all threads of this state
*/
typedef struct global_State {
- char *Mbuffer; /* global buffer */
+ l_char *Mbuffer; /* global buffer */
size_t Mbuffsize; /* size of Mbuffer */
Proto *rootproto; /* list of all prototypes */
Closure *rootcl; /* list of all closures */
@@ -85,7 +85,7 @@ typedef struct global_State {
/*
-** "per thread" state
+** `per thread' state
*/
struct lua_State {
LUA_USERSTATE
diff --git a/lstring.c b/lstring.c
index 660e9db5..7dee4285 100644
--- a/lstring.c
+++ b/lstring.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstring.c,v 1.59 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lstring.c,v 1.60 2001/02/22 17:15:18 roberto Exp roberto $
** String table (keeps all strings handled by Lua)
** See Copyright Notice in lua.h
*/
@@ -63,7 +63,7 @@ static void newentry (lua_State *L, stringtable *tb, TString *ts, int h) {
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l) {
TString *ts;
lu_hash h = l; /* seed */
size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */
@@ -81,7 +81,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
ts->len = l;
ts->u.s.hash = h;
ts->u.s.constindex = 0;
- memcpy(getstr(ts), str, l*sizeof(char));
+ memcpy(getstr(ts), str, l*sizeof(l_char));
getstr(ts)[l] = 0; /* ending 0 */
newentry(L, &G(L)->strt, ts, lmod(h, G(L)->strt.size)); /* insert it */
return ts;
diff --git a/lstring.h b/lstring.h
index dec6c5b4..ad6cca52 100644
--- a/lstring.h
+++ b/lstring.h
@@ -1,5 +1,5 @@
/*
-** $Id: lstring.h,v 1.29 2001/02/09 20:22:29 roberto Exp roberto $
+** $Id: lstring.h,v 1.30 2001/02/20 18:15:33 roberto Exp roberto $
** String table (keep all strings handled by Lua)
** See Copyright Notice in lua.h
*/
@@ -22,20 +22,20 @@
#define sizestring(l) ((lu_mem)sizeof(union L_UTString)+ \
- ((lu_mem)(l)+1)*sizeof(char))
+ ((lu_mem)(l)+1)*sizeof(l_char))
#define sizeudata(l) ((lu_mem)sizeof(union L_UTString)+(l))
#define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s)))
-#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
- (sizeof(s)/sizeof(char))-1))
+#define luaS_newliteral(L, s) (luaS_newlstr(L, l_s("") s, \
+ (sizeof(s)/sizeof(l_char))-1))
void luaS_init (lua_State *L);
void luaS_resize (lua_State *L, stringtable *tb, int newsize);
TString *luaS_newudata (lua_State *L, size_t s, void *udata);
int luaS_createudata (lua_State *L, void *udata, TObject *o);
void luaS_freeall (lua_State *L);
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
+TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l);
#endif
diff --git a/lstrlib.c b/lstrlib.c
index 5fb4de3e..10b57ea8 100644
--- a/lstrlib.c
+++ b/lstrlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstrlib.c,v 1.63 2001/02/22 17:15:18 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.64 2001/02/22 18:59:59 roberto Exp roberto $
** Standard library for string operations and pattern-matching
** See Copyright Notice in lua.h
*/
@@ -36,14 +36,14 @@ static sint32 posrelat (sint32 pos, size_t len) {
static int str_sub (lua_State *L) {
size_t l;
- const char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
sint32 start = posrelat(luaL_check_long(L, 2), l);
sint32 end = posrelat(luaL_opt_long(L, 3, -1), l);
if (start < 1) start = 1;
if (end > (sint32)l) end = l;
if (start <= end)
lua_pushlstring(L, s+start-1, end-start+1);
- else lua_pushliteral(L, "");
+ else lua_pushliteral(L, l_s(""));
return 1;
}
@@ -52,7 +52,7 @@ static int str_lower (lua_State *L) {
size_t l;
size_t i;
luaL_Buffer b;
- const char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
luaL_buffinit(L, &b);
for (i=0; i<l; i++)
luaL_putchar(&b, tolower(uchar(s[i])));
@@ -65,7 +65,7 @@ static int str_upper (lua_State *L) {
size_t l;
size_t i;
luaL_Buffer b;
- const char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
luaL_buffinit(L, &b);
for (i=0; i<l; i++)
luaL_putchar(&b, toupper(uchar(s[i])));
@@ -76,7 +76,7 @@ static int str_upper (lua_State *L) {
static int str_rep (lua_State *L) {
size_t l;
luaL_Buffer b;
- const char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
int n = luaL_check_int(L, 2);
luaL_buffinit(L, &b);
while (n-- > 0)
@@ -88,9 +88,9 @@ static int str_rep (lua_State *L) {
static int str_byte (lua_State *L) {
size_t l;
- const char *s = luaL_check_lstr(L, 1, &l);
+ const l_char *s = luaL_check_lstr(L, 1, &l);
sint32 pos = posrelat(luaL_opt_long(L, 2, 1), l);
- luaL_arg_check(L, 0<pos && (size_t)pos<=l, 2, "out of range");
+ luaL_arg_check(L, 0<pos && (size_t)pos<=l, 2, l_s("out of range"));
lua_pushnumber(L, uchar(s[pos-1]));
return 1;
}
@@ -103,7 +103,7 @@ static int str_char (lua_State *L) {
luaL_buffinit(L, &b);
for (i=1; i<=n; i++) {
int c = luaL_check_int(L, i);
- luaL_arg_check(L, uchar(c) == c, i, "invalid value");
+ luaL_arg_check(L, uchar(c) == c, i, l_s("invalid value"));
luaL_putchar(&b, uchar(c));
}
luaL_pushresult(&b);
@@ -127,25 +127,25 @@ static int str_char (lua_State *L) {
#define CAP_POSITION (-2)
typedef struct MatchState {
- const char *src_init; /* init of source string */
- const char *src_end; /* end (`\0') of source string */
+ const l_char *src_init; /* init of source string */
+ const l_char *src_end; /* end (`\0') of source string */
int level; /* total number of captures (finished or unfinished) */
struct {
- const char *init;
+ const l_char *init;
sint32 len;
} capture[MAX_CAPTURES];
lua_State *L;
} MatchState;
-#define ESC '%'
-#define SPECIALS "^$*+?.([%-"
+#define ESC l_c('%')
+#define SPECIALS l_s("^$*+?.([%-")
static int check_capture (MatchState *ms, int l) {
- l -= '1';
+ l -= l_c('1');
if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
- lua_error(ms->L, "invalid capture index");
+ lua_error(ms->L, l_s("invalid capture index"));
return l;
}
@@ -154,22 +154,22 @@ static int capture_to_close (MatchState *ms) {
int level = ms->level;
for (level--; level>=0; level--)
if (ms->capture[level].len == CAP_UNFINISHED) return level;
- lua_error(ms->L, "invalid pattern capture");
+ lua_error(ms->L, l_s("invalid pattern capture"));
return 0; /* to avoid warnings */
}
-static const char *luaI_classend (MatchState *ms, const char *p) {
+static const l_char *luaI_classend (MatchState *ms, const l_char *p) {
switch (*p++) {
case ESC:
- if (*p == '\0') lua_error(ms->L, "malformed pattern (ends with `%')");
+ if (*p == l_c('\0')) lua_error(ms->L, l_s("malformed pattern (ends with `%')"));
return p+1;
- case '[':
- if (*p == '^') p++;
+ case l_c('['):
+ if (*p == l_c('^')) p++;
do { /* look for a `]' */
- if (*p == '\0') lua_error(ms->L, "malformed pattern (missing `]')");
- if (*(p++) == ESC && *p != '\0') p++; /* skip escapes (e.g. `%]') */
- } while (*p != ']');
+ if (*p == l_c('\0')) lua_error(ms->L, l_s("malformed pattern (missing `]')"));
+ if (*(p++) == ESC && *p != l_c('\0')) p++; /* skip escapes (e.g. `%]') */
+ } while (*p != l_c(']'));
return p+1;
default:
return p;
@@ -177,28 +177,28 @@ static const char *luaI_classend (MatchState *ms, const char *p) {
}
-static int match_class (char c, char cl) {
+static int match_class (l_char c, l_char cl) {
int res;
switch (tolower(uchar(cl))) {
- case 'a' : res = isalpha(uchar(c)); break;
- case 'c' : res = iscntrl(uchar(c)); break;
- case 'd' : res = isdigit(uchar(c)); break;
- case 'l' : res = islower(uchar(c)); break;
- case 'p' : res = ispunct(uchar(c)); break;
- case 's' : res = isspace(uchar(c)); break;
- case 'u' : res = isupper(uchar(c)); break;
- case 'w' : res = isalnum(uchar(c)); break;
- case 'x' : res = isxdigit(uchar(c)); break;
- case 'z' : res = (c == '\0'); break;
+ case l_c('a') : res = isalpha(uchar(c)); break;
+ case l_c('c') : res = iscntrl(uchar(c)); break;
+ case l_c('d') : res = isdigit(uchar(c)); break;
+ case l_c('l') : res = islower(uchar(c)); break;
+ case l_c('p') : res = ispunct(uchar(c)); break;
+ case l_c('s') : res = isspace(uchar(c)); break;
+ case l_c('u') : res = isupper(uchar(c)); break;
+ case l_c('w') : res = isalnum(uchar(c)); break;
+ case l_c('x') : res = isxdigit(uchar(c)); break;
+ case l_c('z') : res = (c == l_c('\0')); break;
default: return (cl == c);
}
return (islower(uchar(cl)) ? res : !res);
}
-static int matchbracketclass (char c, const char *p, const char *endclass) {
+static int matchbracketclass (l_char c, const l_char *p, const l_char *endclass) {
int sig = 1;
- if (*(p+1) == '^') {
+ if (*(p+1) == l_c('^')) {
sig = 0;
p++; /* skip the `^' */
}
@@ -208,7 +208,7 @@ static int matchbracketclass (char c, const char *p, const char *endclass) {
if (match_class(c, *p))
return sig;
}
- else if ((*(p+1) == '-') && (p+2 < endclass)) {
+ else if ((*(p+1) == l_c('-')) && (p+2 < endclass)) {
p+=2;
if (uchar(*(p-2)) <= uchar(c) && uchar(c) <= uchar(*p))
return sig;
@@ -219,13 +219,13 @@ static int matchbracketclass (char c, const char *p, const char *endclass) {
}
-static int luaI_singlematch (char c, const char *p, const char *ep) {
+static int luaI_singlematch (l_char c, const l_char *p, const l_char *ep) {
switch (*p) {
- case '.': /* matches any char */
+ case l_c('.'): /* matches any char */
return 1;
case ESC:
return match_class(c, *(p+1));
- case '[':
+ case l_c('['):
return matchbracketclass(c, p, ep-1);
default:
return (*p == c);
@@ -233,12 +233,12 @@ static int luaI_singlematch (char c, const char *p, const char *ep) {
}
-static const char *match (MatchState *ms, const char *s, const char *p);
+static const l_char *match (MatchState *ms, const l_char *s, const l_char *p);
-static const char *matchbalance (MatchState *ms, const char *s, const char *p) {
+static const l_char *matchbalance (MatchState *ms, const l_char *s, const l_char *p) {
if (*p == 0 || *(p+1) == 0)
- lua_error(ms->L, "unbalanced pattern");
+ lua_error(ms->L, l_s("unbalanced pattern"));
if (*s != *p) return NULL;
else {
int b = *p;
@@ -255,14 +255,14 @@ static const char *matchbalance (MatchState *ms, const char *s, const char *p) {
}
-static const char *max_expand (MatchState *ms, const char *s, const char *p,
- const char *ep) {
+static const l_char *max_expand (MatchState *ms, const l_char *s, const l_char *p,
+ const l_char *ep) {
sint32 i = 0; /* counts maximum expand for item */
while ((s+i)<ms->src_end && luaI_singlematch(*(s+i), p, ep))
i++;
/* keeps trying to match with the maximum repetitions */
while (i>=0) {
- const char *res = match(ms, (s+i), ep+1);
+ const l_char *res = match(ms, (s+i), ep+1);
if (res) return res;
i--; /* else didn't match; reduce 1 repetition to try again */
}
@@ -270,10 +270,10 @@ static const char *max_expand (MatchState *ms, const char *s, const char *p,
}
-static const char *min_expand (MatchState *ms, const char *s, const char *p,
- const char *ep) {
+static const l_char *min_expand (MatchState *ms, const l_char *s, const l_char *p,
+ const l_char *ep) {
for (;;) {
- const char *res = match(ms, s, ep+1);
+ const l_char *res = match(ms, s, ep+1);
if (res != NULL)
return res;
else if (s<ms->src_end && luaI_singlematch(*s, p, ep))
@@ -283,11 +283,11 @@ static const char *min_expand (MatchState *ms, const char *s, const char *p,
}
-static const char *start_capture (MatchState *ms, const char *s,
- const char *p, int what) {
- const char *res;
+static const l_char *start_capture (MatchState *ms, const l_char *s,
+ const l_char *p, int what) {
+ const l_char *res;
int level = ms->level;
- if (level >= MAX_CAPTURES) lua_error(ms->L, "too many captures");
+ if (level >= MAX_CAPTURES) lua_error(ms->L, l_s("too many captures"));
ms->capture[level].init = s;
ms->capture[level].len = what;
ms->level = level+1;
@@ -297,9 +297,9 @@ static const char *start_capture (MatchState *ms, const char *s,
}
-static const char *end_capture (MatchState *ms, const char *s, const char *p) {
+static const l_char *end_capture (MatchState *ms, const l_char *s, const l_char *p) {
int l = capture_to_close(ms);
- const char *res;
+ const l_char *res;
ms->capture[l].len = s - ms->capture[l].init; /* close capture */
if ((res = match(ms, s, p)) == NULL) /* match failed? */
ms->capture[l].len = CAP_UNFINISHED; /* undo capture */
@@ -307,7 +307,7 @@ static const char *end_capture (MatchState *ms, const char *s, const char *p) {
}
-static const char *match_capture (MatchState *ms, const char *s, int level) {
+static const l_char *match_capture (MatchState *ms, const l_char *s, int level) {
int l = check_capture(ms, level);
size_t len = ms->capture[l].len;
if ((size_t)(ms->src_end-s) >= len &&
@@ -317,15 +317,15 @@ static const char *match_capture (MatchState *ms, const char *s, int level) {
}
-static const char *match (MatchState *ms, const char *s, const char *p) {
+static const l_char *match (MatchState *ms, const l_char *s, const l_char *p) {
init: /* using goto's to optimize tail recursion */
switch (*p) {
- case '(': /* start capture */
- if (*(p+1) == ')') /* position capture? */
+ case l_c('('): /* start capture */
+ if (*(p+1) == l_c(')')) /* position capture? */
return start_capture(ms, s, p+2, CAP_POSITION);
else
return start_capture(ms, s, p+1, CAP_UNFINISHED);
- case ')': /* end capture */
+ case l_c(')'): /* end capture */
return end_capture(ms, s, p+1);
case ESC: /* may be %[0-9] or %b */
if (isdigit(uchar(*(p+1)))) { /* capture? */
@@ -333,33 +333,33 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
if (s == NULL) return NULL;
p+=2; goto init; /* else return match(ms, s, p+2) */
}
- else if (*(p+1) == 'b') { /* balanced string? */
+ else if (*(p+1) == l_c('b')) { /* balanced string? */
s = matchbalance(ms, s, p+2);
if (s == NULL) return NULL;
p+=4; goto init; /* else return match(ms, s, p+4); */
}
else goto dflt; /* case default */
- case '\0': /* end of pattern */
+ case l_c('\0'): /* end of pattern */
return s; /* match succeeded */
- case '$':
- if (*(p+1) == '\0') /* is the `$' the last char in pattern? */
+ case l_c('$'):
+ if (*(p+1) == l_c('\0')) /* is the `$' the last char in pattern? */
return (s == ms->src_end) ? s : NULL; /* check end of string */
else goto dflt;
default: dflt: { /* it is a pattern item */
- const char *ep = luaI_classend(ms, p); /* points to what is next */
+ const l_char *ep = luaI_classend(ms, p); /* points to what is next */
int m = s<ms->src_end && luaI_singlematch(*s, p, ep);
switch (*ep) {
- case '?': { /* optional */
- const char *res;
+ case l_c('?'): { /* optional */
+ const l_char *res;
if (m && ((res=match(ms, s+1, ep+1)) != NULL))
return res;
p=ep+1; goto init; /* else return match(ms, s, ep+1); */
}
- case '*': /* 0 or more repetitions */
+ case l_c('*'): /* 0 or more repetitions */
return max_expand(ms, s, p, ep);
- case '+': /* 1 or more repetitions */
+ case l_c('+'): /* 1 or more repetitions */
return (m ? max_expand(ms, s+1, p, ep) : NULL);
- case '-': /* 0 or more repetitions (minimum) */
+ case l_c('-'): /* 0 or more repetitions (minimum) */
return min_expand(ms, s, p, ep);
default:
if (!m) return NULL;
@@ -371,15 +371,15 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
-static const char *lmemfind (const char *s1, size_t l1,
- const char *s2, size_t l2) {
+static const l_char *lmemfind (const l_char *s1, size_t l1,
+ const l_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' */
+ const l_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) {
+ while (l1 > 0 && (init = (const l_char *)memchr(s1, *s2, l1)) != NULL) {
init++; /* 1st char is already checked */
if (memcmp(init, s2+1, l2) == 0)
return init-1;
@@ -395,7 +395,7 @@ static const char *lmemfind (const char *s1, size_t l1,
static void push_onecapture (MatchState *ms, int i) {
int l = ms->capture[i].len;
- if (l == CAP_UNFINISHED) lua_error(ms->L, "unfinished capture");
+ if (l == CAP_UNFINISHED) lua_error(ms->L, l_s("unfinished capture"));
if (l == CAP_POSITION)
lua_pushnumber(ms->L, ms->capture[i].init - ms->src_init + 1);
else
@@ -405,7 +405,7 @@ static void push_onecapture (MatchState *ms, int i) {
static int push_captures (MatchState *ms) {
int i;
- luaL_checkstack(ms->L, ms->level, "too many captures");
+ luaL_checkstack(ms->L, ms->level, l_s("too many captures"));
for (i=0; i<ms->level; i++)
push_onecapture(ms, i);
return ms->level; /* number of strings pushed */
@@ -414,13 +414,13 @@ static int push_captures (MatchState *ms) {
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);
+ const l_char *s = luaL_check_lstr(L, 1, &l1);
+ const l_char *p = luaL_check_lstr(L, 2, &l2);
sint32 init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1;
- luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, "out of range");
+ luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, l_s("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);
+ const l_char *s2 = lmemfind(s+init, l1-init, p, l2);
if (s2) {
lua_pushnumber(L, s2-s+1);
lua_pushnumber(L, s2-s+l2);
@@ -429,13 +429,13 @@ static int str_find (lua_State *L) {
}
else {
MatchState ms;
- int anchor = (*p == '^') ? (p++, 1) : 0;
- const char *s1=s+init;
+ int anchor = (*p == l_c('^')) ? (p++, 1) : 0;
+ const l_char *s1=s+init;
ms.L = L;
ms.src_init = s;
ms.src_end = s+l1;
do {
- const char *res;
+ const l_char *res;
ms.level = 0;
if ((res=match(&ms, s1, p)) != NULL) {
lua_pushnumber(L, s1-s+1); /* start */
@@ -452,7 +452,7 @@ static int str_find (lua_State *L) {
static void add_s (MatchState *ms, luaL_Buffer *b) {
lua_State *L = ms->L;
if (lua_isstring(L, 3)) {
- const char *news = lua_tostring(L, 3);
+ const l_char *news = lua_tostring(L, 3);
size_t l = lua_strlen(L, 3);
size_t i;
for (i=0; i<l; i++) {
@@ -485,22 +485,22 @@ static void add_s (MatchState *ms, luaL_Buffer *b) {
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);
+ const l_char *src = luaL_check_lstr(L, 1, &srcl);
+ const l_char *p = luaL_check_string(L, 2);
int max_s = luaL_opt_int(L, 4, srcl+1);
- int anchor = (*p == '^') ? (p++, 1) : 0;
+ int anchor = (*p == l_c('^')) ? (p++, 1) : 0;
int n = 0;
MatchState ms;
luaL_Buffer b;
luaL_arg_check(L,
lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)),
- 3, "string or function expected");
+ 3, l_s("string or function expected"));
luaL_buffinit(L, &b);
ms.L = L;
ms.src_init = src;
ms.src_end = src+srcl;
while (n < max_s) {
- const char *e;
+ const l_char *e;
ms.level = 0;
e = match(&ms, src, p);
if (e) {
@@ -531,40 +531,40 @@ static int str_gsub (lua_State *L) {
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, '"');
+ const l_char *s = luaL_check_lstr(L, arg, &l);
+ luaL_putchar(b, l_c('"'));
while (l--) {
switch (*s) {
- case '"': case '\\': case '\n':
- luaL_putchar(b, '\\');
+ case l_c('"'): case l_c('\\'): case l_c('\n'):
+ luaL_putchar(b, l_c('\\'));
luaL_putchar(b, *s);
break;
- case '\0': luaL_addlstring(b, "\\000", 4); break;
+ case l_c('\0'): luaL_addlstring(b, l_s("\\000"), 4); break;
default: luaL_putchar(b, *s);
}
s++;
}
- luaL_putchar(b, '"');
+ luaL_putchar(b, l_c('"'));
}
-static const char *scanformat (lua_State *L, const char *strfrmt, char *form,
+static const l_char *scanformat (lua_State *L, const l_char *strfrmt, l_char *form,
int *hasprecision) {
- const char *p = strfrmt;
- while (strchr("-+ #0", *p)) p++; /* skip flags */
+ const l_char *p = strfrmt;
+ while (strchr(l_s("-+ #0"), *p)) p++; /* skip flags */
if (isdigit(uchar(*p))) p++; /* skip width */
if (isdigit(uchar(*p))) p++; /* (2 digits at most) */
- if (*p == '.') {
+ if (*p == l_c('.')) {
p++;
*hasprecision = 1;
if (isdigit(uchar(*p))) p++; /* skip precision */
if (isdigit(uchar(*p))) p++; /* (2 digits at most) */
}
if (isdigit(uchar(*p)))
- lua_error(L, "invalid format (width or precision too long)");
+ lua_error(L, l_s("invalid format (width or precision too long)"));
if (p-strfrmt+2 > MAX_FORMAT) /* +2 to include `%' and the specifier */
- lua_error(L, "invalid format (too long)");
- form[0] = '%';
+ lua_error(L, l_s("invalid format (too long)"));
+ form[0] = l_c('%');
strncpy(form+1, strfrmt, p-strfrmt+1);
form[p-strfrmt+2] = 0;
return p;
@@ -573,38 +573,38 @@ static const char *scanformat (lua_State *L, const char *strfrmt, char *form,
static int str_format (lua_State *L) {
int arg = 1;
- const char *strfrmt = luaL_check_string(L, arg);
+ const l_char *strfrmt = luaL_check_string(L, arg);
luaL_Buffer b;
luaL_buffinit(L, &b);
while (*strfrmt) {
- if (*strfrmt != '%')
+ if (*strfrmt != l_c('%'))
luaL_putchar(&b, *strfrmt++);
- else if (*++strfrmt == '%')
+ else if (*++strfrmt == l_c('%'))
luaL_putchar(&b, *strfrmt++); /* %% */
else { /* format item */
- char form[MAX_FORMAT]; /* to store the format (`%...') */
- char buff[MAX_ITEM]; /* to store the formatted item */
+ l_char form[MAX_FORMAT]; /* to store the format (`%...') */
+ l_char buff[MAX_ITEM]; /* to store the formatted item */
int hasprecision = 0;
- if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == '$')
- lua_error(L, "obsolete `format' option (d$)");
+ if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == l_c('$'))
+ lua_error(L, l_s("obsolete `format' option (d$)"));
arg++;
strfrmt = scanformat(L, strfrmt, form, &hasprecision);
switch (*strfrmt++) {
- case 'c': case 'd': case 'i':
+ case l_c('c'): case l_c('d'): case l_c('i'):
sprintf(buff, form, luaL_check_int(L, arg));
break;
- case 'o': case 'u': case 'x': case 'X':
+ case l_c('o'): case l_c('u'): case l_c('x'): case l_c('X'):
sprintf(buff, form, (unsigned int)luaL_check_number(L, arg));
break;
- case 'e': case 'E': case 'f': case 'g': case 'G':
+ case l_c('e'): case l_c('E'): case l_c('f'): case l_c('g'): case l_c('G'):
sprintf(buff, form, luaL_check_number(L, arg));
break;
- case 'q':
+ case l_c('q'):
luaI_addquoted(L, &b, arg);
continue; /* skip the `addsize' at the end */
- case 's': {
+ case l_c('s'): {
size_t l;
- const char *s = luaL_check_lstr(L, arg, &l);
+ const l_char *s = luaL_check_lstr(L, arg, &l);
if (!hasprecision && l >= 100) {
/* no precision and string is too long to be formatted;
keep original string */
@@ -618,7 +618,7 @@ static int str_format (lua_State *L) {
}
}
default: /* also treat cases `pnLlh' */
- lua_error(L, "invalid option in `format'");
+ lua_error(L, l_s("invalid option in `format'"));
}
luaL_addlstring(&b, buff, strlen(buff));
}
@@ -629,16 +629,16 @@ static int str_format (lua_State *L) {
static const luaL_reg strlib[] = {
-{"strlen", str_len},
-{"strsub", str_sub},
-{"strlower", str_lower},
-{"strupper", str_upper},
-{"strchar", str_char},
-{"strrep", str_rep},
-{"strbyte", str_byte},
-{"format", str_format},
-{"strfind", str_find},
-{"gsub", str_gsub}
+{l_s("strlen"), str_len},
+{l_s("strsub"), str_sub},
+{l_s("strlower"), str_lower},
+{l_s("strupper"), str_upper},
+{l_s("strchar"), str_char},
+{l_s("strrep"), str_rep},
+{l_s("strbyte"), str_byte},
+{l_s("format"), str_format},
+{l_s("strfind"), str_find},
+{l_s("gsub"), str_gsub}
};
diff --git a/ltable.c b/ltable.c
index 8522e8fe..845e639e 100644
--- a/ltable.c
+++ b/ltable.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltable.c,v 1.75 2001/02/01 17:40:48 roberto Exp roberto $
+** $Id: ltable.c,v 1.76 2001/02/20 18:15:33 roberto Exp roberto $
** Lua tables (hash)
** See Copyright Notice in lua.h
*/
@@ -59,9 +59,9 @@ Node *luaH_next (lua_State *L, Hash *t, const TObject *key) {
else {
const TObject *v = luaH_get(t, key);
if (v == &luaO_nilobject)
- luaD_error(L, "invalid key for `next'");
- i = (int)(((const char *)v -
- (const char *)(&t->node[0].val)) / sizeof(Node)) + 1;
+ luaD_error(L, l_s("invalid key for `next'"));
+ i = (int)(((const l_char *)v -
+ (const l_char *)(&t->node[0].val)) / sizeof(Node)) + 1;
}
for (; i<t->size; i++) {
Node *n = node(t, i);
@@ -82,7 +82,7 @@ int luaH_nexti (Hash *t, int i) {
#define check_grow(L, p, n) \
- if ((p) >= MAX_INT/(n)) luaD_error(L, "table overflow");
+ if ((p) >= MAX_INT/(n)) luaD_error(L, l_s("table overflow"));
/*
** returns smaller power of 2 larger than `n' (minimum is MINPOWER2)
@@ -270,7 +270,7 @@ TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) {
case LUA_TNUMBER: return luaH_setnum(L, t, nvalue(key));
case LUA_TSTRING: return luaH_setstr(L, t, tsvalue(key));
case LUA_TNIL:
- if (L) luaD_error(L, "table index is nil");
+ if (L) luaD_error(L, l_s("table index is nil"));
return (TObject *)&luaO_nilobject; /* get option */
default: return luaH_setany(L, t, key);
}
diff --git a/ltests.c b/ltests.c
index b570011b..5cc9f99a 100644
--- a/ltests.c
+++ b/ltests.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltests.c,v 1.70 2001/02/21 16:51:25 roberto Exp roberto $
+** $Id: ltests.c,v 1.71 2001/02/22 18:59:59 roberto Exp roberto $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@@ -42,7 +42,7 @@ int islocked = 0;
-static void setnameval (lua_State *L, const char *name, int val) {
+static void setnameval (lua_State *L, const l_char *name, int val) {
lua_pushstring(L, name);
lua_pushnumber(L, val);
lua_settable(L, -3);
@@ -63,7 +63,7 @@ static void setnameval (lua_State *L, const char *name, int val) {
#define MARK 0x55 /* 01010101 (a nice pattern) */
-#define blocksize(b) ((size_t *)((char *)(b) - HEADER))
+#define blocksize(b) ((size_t *)((l_char *)(b) - HEADER))
unsigned long memdebug_numblocks = 0;
unsigned long memdebug_total = 0;
@@ -76,7 +76,7 @@ static void *checkblock (void *block) {
size_t size = *b;
int i;
for (i=0;i<MARKSIZE;i++)
- lua_assert(*(((char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */
+ lua_assert(*(((l_char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */
return b;
}
@@ -102,11 +102,11 @@ void *debug_realloc (void *block, size_t oldsize, size_t size) {
else if (memdebug_total+size-oldsize > memdebug_memlimit)
return NULL; /* to test memory allocation errors */
else {
- char *newblock;
+ l_char *newblock;
int i;
size_t realsize = HEADER+size+MARKSIZE;
if (realsize < size) return NULL; /* overflow! */
- newblock = (char *)malloc(realsize); /* alloc a new block */
+ newblock = (l_char *)malloc(realsize); /* alloc a new block */
if (newblock == NULL) return NULL;
if (oldsize > size) oldsize = size;
if (block) {
@@ -121,7 +121,7 @@ void *debug_realloc (void *block, size_t oldsize, size_t size) {
memdebug_numblocks++;
*(size_t *)newblock = size;
for (i=0;i<MARKSIZE;i++)
- *(newblock+HEADER+size+i) = (char)(MARK+i);
+ *(newblock+HEADER+size+i) = (l_char)(MARK+i);
return newblock+HEADER;
}
}
@@ -138,36 +138,36 @@ void *debug_realloc (void *block, size_t oldsize, size_t size) {
*/
-static const char *const instrname[NUM_OPCODES] = {
- "RETURN", "CALL", "TAILCALL", "PUSHNIL", "POP", "PUSHINT",
- "PUSHSTRING", "PUSHNUM", "PUSHNEGNUM", "PUSHUPVALUE", "GETLOCAL",
- "GETGLOBAL", "GETTABLE", "GETDOTTED", "GETINDEXED", "PUSHSELF",
- "CREATETABLE", "SETLOCAL", "SETGLOBAL", "SETTABLE", "SETLIST", "SETMAP",
- "ADD", "ADDI", "SUB", "MULT", "DIV", "POW", "CONCAT", "MINUS", "NOT",
- "JMPNE", "JMPEQ", "JMPLT", "JMPLE", "JMPGT", "JMPGE", "JMPT", "JMPF",
- "JMPONT", "JMPONF", "JMP", "PUSHNILJMP", "FORPREP", "FORLOOP", "LFORPREP",
- "LFORLOOP", "CLOSURE"
+static const l_char *const instrname[NUM_OPCODES] = {
+ l_s("RETURN"), l_s("CALL"), l_s("TAILCALL"), l_s("PUSHNIL"), l_s("POP"), l_s("PUSHINT"),
+ l_s("PUSHSTRING"), l_s("PUSHNUM"), l_s("PUSHNEGNUM"), l_s("PUSHUPVALUE"), l_s("GETLOCAL"),
+ l_s("GETGLOBAL"), l_s("GETTABLE"), l_s("GETDOTTED"), l_s("GETINDEXED"), l_s("PUSHSELF"),
+ l_s("CREATETABLE"), l_s("SETLOCAL"), l_s("SETGLOBAL"), l_s("SETTABLE"), l_s("SETLIST"), l_s("SETMAP"),
+ l_s("ADD"), l_s("ADDI"), l_s("SUB"), l_s("MULT"), l_s("DIV"), l_s("POW"), l_s("CONCAT"), l_s("MINUS"), l_s("NOT"),
+ l_s("JMPNE"), l_s("JMPEQ"), l_s("JMPLT"), l_s("JMPLE"), l_s("JMPGT"), l_s("JMPGE"), l_s("JMPT"), l_s("JMPF"),
+ l_s("JMPONT"), l_s("JMPONF"), l_s("JMP"), l_s("PUSHNILJMP"), l_s("FORPREP"), l_s("FORLOOP"), l_s("LFORPREP"),
+ l_s("LFORLOOP"), l_s("CLOSURE")
};
static void pushop (lua_State *L, Proto *p, int pc) {
- char buff[100];
+ l_char buff[100];
Instruction i = p->code[pc];
OpCode o = GET_OPCODE(i);
- const char *name = instrname[o];
- sprintf(buff, "%5d - ", luaG_getline(p->lineinfo, pc, 1, NULL));
+ const l_char *name = instrname[o];
+ sprintf(buff, l_s("%5d - "), luaG_getline(p->lineinfo, pc, 1, NULL));
switch ((enum Mode)luaK_opproperties[o].mode) {
case iO:
- sprintf(buff+8, "%-12s", name);
+ sprintf(buff+8, l_s("%-12s"), name);
break;
case iU:
- sprintf(buff+8, "%-12s%4u", name, GETARG_U(i));
+ sprintf(buff+8, l_s("%-12s%4u"), name, GETARG_U(i));
break;
case iS:
- sprintf(buff+8, "%-12s%4d", name, GETARG_S(i));
+ sprintf(buff+8, l_s("%-12s%4d"), name, GETARG_S(i));
break;
case iAB:
- sprintf(buff+8, "%-12s%4d %4d", name, GETARG_A(i), GETARG_B(i));
+ sprintf(buff+8, l_s("%-12s%4d %4d"), name, GETARG_A(i), GETARG_B(i));
break;
}
lua_pushstring(L, buff);
@@ -178,11 +178,11 @@ static int listcode (lua_State *L) {
int pc;
Proto *p;
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
- 1, "Lua function expected");
+ 1, l_s("Lua function expected"));
p = clvalue(luaA_index(L, 1))->f.l;
lua_newtable(L);
- setnameval(L, "maxstack", p->maxstacksize);
- setnameval(L, "numparams", p->numparams);
+ setnameval(L, l_s("maxstack"), p->maxstacksize);
+ setnameval(L, l_s("numparams"), p->numparams);
for (pc=0; pc<p->sizecode; pc++) {
lua_pushnumber(L, pc+1);
pushop(L, p, pc);
@@ -196,7 +196,7 @@ static int liststrings (lua_State *L) {
Proto *p;
int i;
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
- 1, "Lua function expected");
+ 1, l_s("Lua function expected"));
p = clvalue(luaA_index(L, 1))->f.l;
lua_newtable(L);
for (i=0; i<p->sizekstr; i++) {
@@ -212,9 +212,9 @@ static int listlocals (lua_State *L) {
Proto *p;
int pc = luaL_check_int(L, 2) - 1;
int i = 0;
- const char *name;
+ const l_char *name;
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
- 1, "Lua function expected");
+ 1, l_s("Lua function expected"));
p = clvalue(luaA_index(L, 1))->f.l;
while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
lua_pushstring(L, name);
@@ -234,22 +234,22 @@ static int pushbool (lua_State *L, int b) {
static int get_limits (lua_State *L) {
lua_newtable(L);
- setnameval(L, "BITS_INT", BITS_INT);
- setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
- setnameval(L, "MAXARG_A", MAXARG_A);
- setnameval(L, "MAXARG_B", MAXARG_B);
- setnameval(L, "MAXARG_S", MAXARG_S);
- setnameval(L, "MAXARG_U", MAXARG_U);
- setnameval(L, "MAXLOCALS", MAXLOCALS);
- setnameval(L, "MAXPARAMS", MAXPARAMS);
- setnameval(L, "MAXSTACK", MAXSTACK);
- setnameval(L, "MAXUPVALUES", MAXUPVALUES);
- setnameval(L, "MAXVARSLH", MAXVARSLH);
- setnameval(L, "RFPF", RFIELDS_PER_FLUSH);
- setnameval(L, "SIZE_A", SIZE_A);
- setnameval(L, "SIZE_B", SIZE_B);
- setnameval(L, "SIZE_OP", SIZE_OP);
- setnameval(L, "SIZE_U", SIZE_U);
+ setnameval(L, l_s("BITS_INT"), BITS_INT);
+ setnameval(L, l_s("LFPF"), LFIELDS_PER_FLUSH);
+ setnameval(L, l_s("MAXARG_A"), MAXARG_A);
+ setnameval(L, l_s("MAXARG_B"), MAXARG_B);
+ setnameval(L, l_s("MAXARG_S"), MAXARG_S);
+ setnameval(L, l_s("MAXARG_U"), MAXARG_U);
+ setnameval(L, l_s("MAXLOCALS"), MAXLOCALS);
+ setnameval(L, l_s("MAXPARAMS"), MAXPARAMS);
+ setnameval(L, l_s("MAXSTACK"), MAXSTACK);
+ setnameval(L, l_s("MAXUPVALUES"), MAXUPVALUES);
+ setnameval(L, l_s("MAXVARSLH"), MAXVARSLH);
+ setnameval(L, l_s("RFPF"), RFIELDS_PER_FLUSH);
+ setnameval(L, l_s("SIZE_A"), SIZE_A);
+ setnameval(L, l_s("SIZE_B"), SIZE_B);
+ setnameval(L, l_s("SIZE_OP"), SIZE_OP);
+ setnameval(L, l_s("SIZE_U"), SIZE_U);
return 1;
}
@@ -270,7 +270,7 @@ static int mem_query (lua_State *L) {
static int hash_query (lua_State *L) {
if (lua_isnull(L, 2)) {
- luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, "string expected");
+ luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, l_s("string expected"));
lua_pushnumber(L, tsvalue(luaA_index(L, 1))->u.s.hash);
}
else {
@@ -313,7 +313,7 @@ static int table_query (lua_State *L) {
static int string_query (lua_State *L) {
- stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &G(L)->strt :
+ stringtable *tb = (*luaL_check_string(L, 1) == l_c('s')) ? &G(L)->strt :
&G(L)->udt;
int s = luaL_opt_int(L, 2, 0) - 1;
if (s==-1) {
@@ -364,8 +364,8 @@ static int newuserdata (lua_State *L) {
}
else {
size_t size = luaL_check_int(L, 1);
- char *p = (char *)lua_newuserdata(L, size);
- while (size--) *p++ = '\0';
+ l_char *p = (l_char *)lua_newuserdata(L, size);
+ while (size--) *p++ = l_c('\0');
return 1;
}
}
@@ -400,7 +400,7 @@ static int s2d (lua_State *L) {
static int d2s (lua_State *L) {
double d = luaL_check_number(L, 1);
- lua_pushlstring(L, (char *)&d, sizeof(d));
+ lua_pushlstring(L, (l_char *)&d, sizeof(d));
return 1;
}
@@ -419,12 +419,12 @@ static int newstate (lua_State *L) {
static int loadlib (lua_State *L) {
lua_State *L1 = (lua_State *)lua_touserdata(L, 1);
switch (*luaL_check_string(L, 2)) {
- case 'm': lua_mathlibopen(L1); break;
- case 's': lua_strlibopen(L1); break;
- case 'i': lua_iolibopen(L1); break;
- case 'd': lua_dblibopen(L1); break;
- case 'b': lua_baselibopen(L1); break;
- default: luaL_argerror(L, 2, "invalid option");
+ case l_c('m'): lua_mathlibopen(L1); break;
+ case l_c('s'): lua_strlibopen(L1); break;
+ case l_c('i'): lua_iolibopen(L1); break;
+ case l_c('d'): lua_dblibopen(L1); break;
+ case l_c('b'): lua_baselibopen(L1); break;
+ default: luaL_argerror(L, 2, l_s("invalid option"));
}
return 0;
}
@@ -438,7 +438,7 @@ static int closestate (lua_State *L) {
static int doremote (lua_State *L) {
lua_State *L1;
- const char *code = luaL_check_string(L, 2);
+ const l_char *code = luaL_check_string(L, 2);
int status;
L1 = (lua_State *)(unsigned long)luaL_check_number(L, 1);
status = lua_dostring(L1, code);
@@ -457,7 +457,7 @@ static int doremote (lua_State *L) {
static int settagmethod (lua_State *L) {
int tag = luaL_check_int(L, 1);
- const char *event = luaL_check_string(L, 2);
+ const l_char *event = luaL_check_string(L, 2);
luaL_checkany(L, 3);
lua_gettagmethod(L, tag, event);
lua_pushvalue(L, 3);
@@ -478,36 +478,36 @@ static int equal (lua_State *L) {
** =======================================================
*/
-static const char *const delimits = " \t\n,;";
+static const l_char *const delimits = l_s(" \t\n,;");
-static void skip (const char **pc) {
- while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
+static void skip (const l_char **pc) {
+ while (**pc != l_c('\0') && strchr(delimits, **pc)) (*pc)++;
}
-static int getnum (lua_State *L, const char **pc) {
+static int getnum (lua_State *L, const l_char **pc) {
int res = 0;
int sig = 1;
skip(pc);
- if (**pc == '.') {
+ if (**pc == l_c('.')) {
res = (int)lua_tonumber(L, -1);
lua_pop(L, 1);
(*pc)++;
return res;
}
- else if (**pc == '-') {
+ else if (**pc == l_c('-')) {
sig = -1;
(*pc)++;
}
- while (isdigit(**pc)) res = res*10 + (*(*pc)++) - '0';
+ while (isdigit(**pc)) res = res*10 + (*(*pc)++) - l_c('0');
return sig*res;
}
-static const char *getname (char *buff, const char **pc) {
+static const l_char *getname (l_char *buff, const l_char **pc) {
int i = 0;
skip(pc);
- while (**pc != '\0' && !strchr(delimits, **pc))
+ while (**pc != l_c('\0') && !strchr(delimits, **pc))
buff[i++] = *(*pc)++;
- buff[i] = '\0';
+ buff[i] = l_c('\0');
return buff;
}
@@ -519,121 +519,121 @@ static const char *getname (char *buff, const char **pc) {
static int testC (lua_State *L) {
- char buff[30];
- const char *pc = luaL_check_string(L, 1);
+ l_char buff[30];
+ const l_char *pc = luaL_check_string(L, 1);
for (;;) {
- const char *inst = getname;
- if EQ("") return 0;
- else if EQ("isnumber") {
+ const l_char *inst = getname;
+ if EQ(l_s("")) return 0;
+ else if EQ(l_s("isnumber")) {
lua_pushnumber(L, lua_isnumber(L, getnum));
}
- else if EQ("isstring") {
+ else if EQ(l_s("isstring")) {
lua_pushnumber(L, lua_isstring(L, getnum));
}
- else if EQ("istable") {
+ else if EQ(l_s("istable")) {
lua_pushnumber(L, lua_istable(L, getnum));
}
- else if EQ("iscfunction") {
+ else if EQ(l_s("iscfunction")) {
lua_pushnumber(L, lua_iscfunction(L, getnum));
}
- else if EQ("isfunction") {
+ else if EQ(l_s("isfunction")) {
lua_pushnumber(L, lua_isfunction(L, getnum));
}
- else if EQ("isuserdata") {
+ else if EQ(l_s("isuserdata")) {
lua_pushnumber(L, lua_isuserdata(L, getnum));
}
- else if EQ("isnil") {
+ else if EQ(l_s("isnil")) {
lua_pushnumber(L, lua_isnil(L, getnum));
}
- else if EQ("isnull") {
+ else if EQ(l_s("isnull")) {
lua_pushnumber(L, lua_isnull(L, getnum));
}
- else if EQ("tonumber") {
+ else if EQ(l_s("tonumber")) {
lua_pushnumber(L, lua_tonumber(L, getnum));
}
- else if EQ("tostring") {
- const char *s = lua_tostring(L, getnum);
+ else if EQ(l_s("tostring")) {
+ const l_char *s = lua_tostring(L, getnum);
lua_pushstring(L, s);
}
- else if EQ("tonumber") {
+ else if EQ(l_s("tonumber")) {
lua_pushnumber(L, lua_tonumber(L, getnum));
}
- else if EQ("strlen") {
+ else if EQ(l_s("strlen")) {
lua_pushnumber(L, lua_strlen(L, getnum));
}
- else if EQ("tocfunction") {
+ else if EQ(l_s("tocfunction")) {
lua_pushcfunction(L, lua_tocfunction(L, getnum));
}
- else if EQ("return") {
+ else if EQ(l_s("return")) {
return getnum;
}
- else if EQ("gettop") {
+ else if EQ(l_s("gettop")) {
lua_pushnumber(L, lua_gettop(L));
}
- else if EQ("settop") {
+ else if EQ(l_s("settop")) {
lua_settop(L, getnum);
}
- else if EQ("pop") {
+ else if EQ(l_s("pop")) {
lua_pop(L, getnum);
}
- else if EQ("pushnum") {
+ else if EQ(l_s("pushnum")) {
lua_pushnumber(L, getnum);
}
- else if EQ("pushvalue") {
+ else if EQ(l_s("pushvalue")) {
lua_pushvalue(L, getnum);
}
- else if EQ("remove") {
+ else if EQ(l_s("remove")) {
lua_remove(L, getnum);
}
- else if EQ("insert") {
+ else if EQ(l_s("insert")) {
lua_insert(L, getnum);
}
- else if EQ("gettable") {
+ else if EQ(l_s("gettable")) {
lua_gettable(L, getnum);
}
- else if EQ("settable") {
+ else if EQ(l_s("settable")) {
lua_settable(L, getnum);
}
- else if EQ("next") {
+ else if EQ(l_s("next")) {
lua_next(L, -2);
}
- else if EQ("concat") {
+ else if EQ(l_s("concat")) {
lua_concat(L, getnum);
}
- else if EQ("lessthan") {
+ else if EQ(l_s("lessthan")) {
int a = getnum;
if (lua_lessthan(L, a, getnum))
lua_pushnumber(L, 1);
else
lua_pushnil(L);
}
- else if EQ("rawcall") {
+ else if EQ(l_s("rawcall")) {
int narg = getnum;
int nres = getnum;
lua_rawcall(L, narg, nres);
}
- else if EQ("call") {
+ else if EQ(l_s("call")) {
int narg = getnum;
int nres = getnum;
lua_call(L, narg, nres);
}
- else if EQ("dostring") {
+ else if EQ(l_s("dostring")) {
lua_dostring(L, luaL_check_string(L, getnum));
}
- else if EQ("settagmethod") {
+ else if EQ(l_s("settagmethod")) {
int tag = getnum;
- const char *event = getname;
+ const l_char *event = getname;
lua_settagmethod(L, tag, event);
}
- else if EQ("gettagmethod") {
+ else if EQ(l_s("gettagmethod")) {
int tag = getnum;
- const char *event = getname;
+ const l_char *event = getname;
lua_gettagmethod(L, tag, event);
}
- else if EQ("type") {
+ else if EQ(l_s("type")) {
lua_pushstring(L, lua_typename(L, lua_type(L, getnum)));
}
- else luaL_verror(L, "unknown instruction %.30s", buff);
+ else luaL_verror(L, l_s("unknown instruction %.30s"), buff);
}
return 0;
}
@@ -643,30 +643,30 @@ static int testC (lua_State *L) {
static const struct luaL_reg tests_funcs[] = {
- {"hash", hash_query},
- {"limits", get_limits},
- {"listcode", listcode},
- {"liststrings", liststrings},
- {"listlocals", listlocals},
- {"loadlib", loadlib},
- {"querystr", string_query},
- {"querytab", table_query},
- {"testC", testC},
- {"ref", tref},
- {"getref", getref},
- {"unref", unref},
- {"d2s", d2s},
- {"s2d", s2d},
- {"newuserdata", newuserdata},
- {"udataval", udataval},
- {"newtag", newtag},
- {"doonnewstack", doonnewstack},
- {"newstate", newstate},
- {"closestate", closestate},
- {"doremote", doremote},
- {"settagmethod", settagmethod},
- {"equal", equal},
- {"totalmem", mem_query}
+ {l_s("hash"), hash_query},
+ {l_s("limits"), get_limits},
+ {l_s("listcode"), listcode},
+ {l_s("liststrings"), liststrings},
+ {l_s("listlocals"), listlocals},
+ {l_s("loadlib"), loadlib},
+ {l_s("querystr"), string_query},
+ {l_s("querytab"), table_query},
+ {l_s("testC"), testC},
+ {l_s("ref"), tref},
+ {l_s("getref"), getref},
+ {l_s("unref"), unref},
+ {l_s("d2s"), d2s},
+ {l_s("s2d"), s2d},
+ {l_s("newuserdata"), newuserdata},
+ {l_s("udataval"), udataval},
+ {l_s("newtag"), newtag},
+ {l_s("doonnewstack"), doonnewstack},
+ {l_s("newstate"), newstate},
+ {l_s("closestate"), closestate},
+ {l_s("doremote"), doremote},
+ {l_s("settagmethod"), settagmethod},
+ {l_s("equal"), equal},
+ {l_s("totalmem"), mem_query}
};
@@ -680,7 +680,7 @@ void luaB_opentests (lua_State *L) {
lua_setglobals(L);
luaL_openl(L, tests_funcs); /* open functions inside new table */
lua_setglobals(L); /* restore old table of globals */
- lua_setglobal(L, "T"); /* set new table as global T */
+ lua_setglobal(L, l_s("T")); /* set new table as global T */
}
#endif
diff --git a/ltm.c b/ltm.c
index 43bdc0f8..aff4a227 100644
--- a/ltm.c
+++ b/ltm.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltm.c,v 1.67 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: ltm.c,v 1.68 2001/02/22 18:59:59 roberto Exp roberto $
** Tag methods
** See Copyright Notice in lua.h
*/
@@ -19,15 +19,15 @@
#include "ltm.h"
-const char *const luaT_eventname[] = { /* ORDER TM */
- "gettable", "settable", "index", "getglobal", "setglobal", "add", "sub",
- "mul", "div", "pow", "unm", "lt", "concat", "gc", "function",
- "le", "gt", "ge", /* deprecated options!! */
+const l_char *const luaT_eventname[] = { /* ORDER TM */
+ l_s("gettable"), l_s("settable"), l_s("index"), l_s("getglobal"), l_s("setglobal"), l_s("add"), l_s("sub"),
+ l_s("mul"), l_s("div"), l_s("pow"), l_s("unm"), l_s("lt"), l_s("concat"), l_s("gc"), l_s("function"),
+ l_s("le"), l_s("gt"), l_s("ge"), /* deprecated options!! */
NULL
};
-static int findevent (const char *name) {
+static int findevent (const l_char *name) {
int i;
for (i=0; luaT_eventname[i]; i++)
if (strcmp(luaT_eventname[i], name) == 0)
@@ -36,14 +36,14 @@ static int findevent (const char *name) {
}
-static int luaI_checkevent (lua_State *L, const char *name, int t) {
+static int luaI_checkevent (lua_State *L, const l_char *name, int t) {
int e = findevent(name);
if (e >= TM_N)
- luaO_verror(L, "event `%.50s' is deprecated", name);
+ luaO_verror(L, l_s("event `%.50s' is deprecated"), name);
if (e == TM_GC && t == LUA_TTABLE)
- luaO_verror(L, "event `gc' for tables is deprecated");
+ luaO_verror(L, l_s("event `gc' for tables is deprecated"));
if (e < 0)
- luaO_verror(L, "`%.50s' is not a valid event name", name);
+ luaO_verror(L, l_s("`%.50s' is not a valid event name"), name);
return e;
}
@@ -68,8 +68,8 @@ int luaT_validevent (int t, int e) { /* ORDER LUA_T */
void luaT_init (lua_State *L) {
- static const char *const typenames[NUM_TAGS] = {
- "userdata", "nil", "number", "string", "table", "function"
+ static const l_char *const typenames[NUM_TAGS] = {
+ l_s("userdata"), l_s("nil"), l_s("number"), l_s("string"), l_s("table"), l_s("function")
};
int i;
for (i=0; i<NUM_TAGS; i++)
@@ -77,12 +77,12 @@ void luaT_init (lua_State *L) {
}
-int luaT_newtag (lua_State *L, const char *name, int basictype) {
+int luaT_newtag (lua_State *L, const l_char *name, int basictype) {
int tag;
int i;
TString *ts;
luaM_growvector(L, G(L)->TMtable, G(L)->ntag, G(L)->sizeTM, struct TM,
- MAX_INT, "tag table overflow");
+ MAX_INT, l_s("tag table overflow"));
tag = G(L)->ntag;
if (name == NULL)
ts = NULL;
@@ -105,7 +105,7 @@ int luaT_newtag (lua_State *L, const char *name, int basictype) {
static void checktag (lua_State *L, int tag) {
if (!(0 <= tag && tag < G(L)->ntag))
- luaO_verror(L, "%d is not a valid tag", tag);
+ luaO_verror(L, l_s("%d is not a valid tag"), tag);
}
@@ -133,7 +133,7 @@ int luaT_tag (const TObject *o) {
}
-const char *luaT_typename (global_State *G, const TObject *o) {
+const l_char *luaT_typename (global_State *G, const TObject *o) {
int t = ttype(o);
int tag;
TString *ts;
@@ -154,7 +154,7 @@ const char *luaT_typename (global_State *G, const TObject *o) {
}
-LUA_API void lua_gettagmethod (lua_State *L, int t, const char *event) {
+LUA_API void lua_gettagmethod (lua_State *L, int t, const l_char *event) {
int e;
LUA_LOCK(L);
e = luaI_checkevent(L, event, t);
@@ -169,16 +169,16 @@ LUA_API void lua_gettagmethod (lua_State *L, int t, const char *event) {
}
-LUA_API void lua_settagmethod (lua_State *L, int t, const char *event) {
+LUA_API void lua_settagmethod (lua_State *L, int t, const l_char *event) {
int e;
LUA_LOCK(L);
e = luaI_checkevent(L, event, t);
checktag(L, t);
if (!luaT_validevent(t, e))
- luaO_verror(L, "cannot change `%.20s' tag method for type `%.20s'%.20s",
+ luaO_verror(L, l_s("cannot change `%.20s' tag method for type `%.20s'%.20s"),
luaT_eventname[e], basictypename(G(L), t),
(t == LUA_TTABLE || t == LUA_TUSERDATA) ?
- " with default tag" : "");
+ l_s(" with default tag") : l_s(""));
switch (ttype(L->top - 1)) {
case LUA_TNIL:
luaT_gettm(G(L), t, e) = NULL;
@@ -187,7 +187,7 @@ LUA_API void lua_settagmethod (lua_State *L, int t, const char *event) {
luaT_gettm(G(L), t, e) = clvalue(L->top - 1);
break;
default:
- luaD_error(L, "tag method must be a function (or nil)");
+ luaD_error(L, l_s("tag method must be a function (or nil)"));
}
L->top--;
LUA_UNLOCK(L);
diff --git a/ltm.h b/ltm.h
index 13759c5c..53572bd2 100644
--- a/ltm.h
+++ b/ltm.h
@@ -1,5 +1,5 @@
/*
-** $Id: ltm.h,v 1.22 2001/01/25 16:45:36 roberto Exp roberto $
+** $Id: ltm.h,v 1.23 2001/02/09 20:22:29 roberto Exp roberto $
** Tag methods
** See Copyright Notice in lua.h
*/
@@ -67,12 +67,12 @@ struct TM {
#define validtag(G,t) (NUM_TAGS <= (t) && (t) < G->ntag)
-extern const char *const luaT_eventname[];
+extern const l_char *const luaT_eventname[];
void luaT_init (lua_State *L);
-int luaT_newtag (lua_State *L, const char *name, int basictype);
-const char *luaT_typename (global_State *G, const TObject *o);
+int luaT_newtag (lua_State *L, const l_char *name, int basictype);
+const l_char *luaT_typename (global_State *G, const TObject *o);
int luaT_tag (const TObject *o);
int luaT_validevent (int t, int e); /* used by compatibility module */
diff --git a/lua.c b/lua.c
index 6d76d03c..43310326 100644
--- a/lua.c
+++ b/lua.c
@@ -1,5 +1,5 @@
/*
-** $Id: lua.c,v 1.60 2001/02/14 17:19:01 roberto Exp roberto $
+** $Id: lua.c,v 1.61 2001/02/20 18:15:33 roberto Exp roberto $
** Lua stand-alone interpreter
** See Copyright Notice in lua.h
*/
@@ -25,7 +25,7 @@ static int isatty (int x) { return x==0; } /* assume stdin is a tty */
#ifndef PROMPT
-#define PROMPT "> "
+#define PROMPT l_s("> ")
#endif
@@ -70,7 +70,7 @@ static void lstop (void) {
lua_setlinehook(L, old_linehook);
lua_setcallhook(L, old_callhook);
lreset();
- lua_error(L, "interrupted!");
+ lua_error(L, l_s("interrupted!"));
}
@@ -83,7 +83,7 @@ static void laction (int i) {
}
-static int ldo (int (*f)(lua_State *l, const char *), const char *name) {
+static int ldo (int (*f)(lua_State *l, const l_char *), const l_char *name) {
int res;
handler h = lreset();
int top = lua_gettop(L);
@@ -92,45 +92,45 @@ static int ldo (int (*f)(lua_State *l, const char *), const char *name) {
signal(SIGINT, h); /* restore old action */
/* Lua gives no message in such cases, so lua.c provides one */
if (res == LUA_ERRMEM) {
- fprintf(stderr, "lua: memory allocation error\n");
+ fprintf(stderr, l_s("lua: memory allocation error\n"));
}
else if (res == LUA_ERRERR)
- fprintf(stderr, "lua: error in error message\n");
+ fprintf(stderr, l_s("lua: error in error message\n"));
return res;
}
static void print_message (void) {
fprintf(stderr,
- "usage: lua [options]. Available options are:\n"
- " - execute stdin as a file\n"
- " -c close Lua when exiting\n"
- " -e stat execute string `stat'\n"
- " -f name execute file `name' with remaining arguments in table `arg'\n"
- " -i enter interactive mode with prompt\n"
- " -q enter interactive mode without prompt\n"
- " -sNUM set stack size to NUM (must be the first option)\n"
- " -v print version information\n"
- " a=b set global `a' to string `b'\n"
- " name execute file `name'\n"
+ l_s("usage: lua [options]. Available options are:\n")
+ l_s(" - execute stdin as a file\n")
+ l_s(" -c close Lua when exiting\n")
+ l_s(" -e stat execute string `stat'\n")
+ l_s(" -f name execute file `name' with remaining arguments in table `arg'\n")
+ l_s(" -i enter interactive mode with prompt\n")
+ l_s(" -q enter interactive mode without prompt\n")
+ l_s(" -sNUM set stack size to NUM (must be the first option)\n")
+ l_s(" -v print version information\n")
+ l_s(" a=b set global `a' to string `b'\n")
+ l_s(" name execute file `name'\n")
);
}
static void print_version (void) {
- printf("%.80s %.80s\n", LUA_VERSION, LUA_COPYRIGHT);
+ printf(l_s("%.80s %.80s\n"), l_s(LUA_VERSION), l_s(LUA_COPYRIGHT));
}
-static void assign (char *arg) {
- char *eq = strchr(arg, '=');
- *eq = '\0'; /* spilt `arg' in two strings (name & value) */
+static void assign (l_char *arg) {
+ l_char *eq = strchr(arg, l_c('='));
+ *eq = l_c('\0'); /* spilt `arg' in two strings (name & value) */
lua_pushstring(L, eq+1);
lua_setglobal(L, arg);
}
-static void getargs (char *argv[]) {
+static void getargs (l_char *argv[]) {
int i;
lua_newtable(L);
for (i=0; argv[i]; i++) {
@@ -140,24 +140,24 @@ static void getargs (char *argv[]) {
lua_settable(L, -3);
}
/* arg.n = maximum index in table `arg' */
- lua_pushliteral(L, "n");
+ lua_pushliteral(L, l_s("n"));
lua_pushnumber(L, i-1);
lua_settable(L, -3);
}
static int l_getargs (lua_State *l) {
- char **argv = (char **)lua_touserdata(l, -1);
+ l_char **argv = (l_char **)lua_touserdata(l, -1);
getargs(argv);
return 1;
}
-static int file_input (const char *argv) {
+static int file_input (const l_char *argv) {
int result = ldo(lua_dofile, argv);
if (result) {
if (result == LUA_ERRFILE) {
- fprintf(stderr, "lua: cannot execute file ");
+ fprintf(stderr, l_s("lua: cannot execute file "));
perror(argv);
}
return EXIT_FAILURE;
@@ -173,12 +173,12 @@ static int file_input (const char *argv) {
#endif
-static const char *get_prompt (int prompt) {
+static const l_char *get_prompt (int prompt) {
if (!prompt)
- return "";
+ return l_s("");
else {
- const char *s;
- lua_getglobal(L, "_PROMPT");
+ const l_char *s;
+ lua_getglobal(L, l_s("_PROMPT"));
s = lua_tostring(L, -1);
if (!s) s = PROMPT;
lua_pop(L, 1); /* remove global */
@@ -192,15 +192,15 @@ static void manual_input (int version, int prompt) {
for (;;) {
fputs(get_prompt(prompt), stdout); /* show prompt */
for(;;) {
- char buffer[MAXINPUT];
+ l_char buffer[MAXINPUT];
size_t l;
if (fgets(buffer, sizeof(buffer), stdin) == NULL) {
- printf("\n");
+ printf(l_s("\n"));
return;
}
l = strlen(buffer);
- if (buffer[l-1] == '\n' && buffer[l-2] == '\\') {
- buffer[l-2] = '\n';
+ if (buffer[l-1] == l_c('\n') && buffer[l-2] == l_c('\\')) {
+ buffer[l-2] = l_c('\n');
lua_pushlstring(L, buffer, l-1);
}
else {
@@ -215,7 +215,7 @@ static void manual_input (int version, int prompt) {
}
-static int handle_argv (char *argv[], struct Options *opt) {
+static int handle_argv (l_char *argv[], struct Options *opt) {
if (opt->stacksize > 0) argv++; /* skip option `-s' (if present) */
if (*argv == NULL) { /* no more arguments? */
if (isatty(0)) {
@@ -227,8 +227,8 @@ static int handle_argv (char *argv[], struct Options *opt) {
else { /* other arguments; loop over them */
int i;
for (i = 0; argv[i] != NULL; i++) {
- if (argv[i][0] != '-') { /* not an option? */
- if (strchr(argv[i], '='))
+ if (argv[i][0] != l_c('-')) { /* not an option? */
+ if (strchr(argv[i], l_c('=')))
assign(argv[i]);
else
if (file_input(argv[i]) != EXIT_SUCCESS)
@@ -239,46 +239,46 @@ static int handle_argv (char *argv[], struct Options *opt) {
ldo(lua_dofile, NULL); /* executes stdin as a file */
break;
}
- case 'i': {
+ case l_c('i'): {
manual_input(0, 1);
break;
}
- case 'q': {
+ case l_c('q'): {
manual_input(0, 0);
break;
}
- case 'c': {
+ case l_c('c'): {
opt->toclose = 1;
break;
}
- case 'v': {
+ case l_c('v'): {
print_version();
break;
}
- case 'e': {
+ case l_c('e'): {
i++;
if (argv[i] == NULL) {
print_message();
return EXIT_FAILURE;
}
if (ldo(lua_dostring, argv[i]) != 0) {
- fprintf(stderr, "lua: error running argument `%.99s'\n", argv[i]);
+ fprintf(stderr, l_s("lua: error running argument `%.99s'\n"), argv[i]);
return EXIT_FAILURE;
}
break;
}
- case 'f': {
+ case l_c('f'): {
i++;
if (argv[i] == NULL) {
print_message();
return EXIT_FAILURE;
}
getargs(argv+i); /* collect remaining arguments */
- lua_setglobal(L, "arg");
+ lua_setglobal(L, l_s("arg"));
return file_input(argv[i]); /* stop scanning arguments */
}
- case 's': {
- fprintf(stderr, "lua: stack size (`-s') must be the first option\n");
+ case l_c('s'): {
+ fprintf(stderr, l_s("lua: stack size (`-s') must be the first option\n"));
return EXIT_FAILURE;
}
default: {
@@ -292,11 +292,11 @@ static int handle_argv (char *argv[], struct Options *opt) {
}
-static void getstacksize (int argc, char *argv[], struct Options *opt) {
- if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 's') {
+static void getstacksize (int argc, l_char *argv[], struct Options *opt) {
+ if (argc >= 2 && argv[1][0] == l_c('-') && argv[1][1] == l_c('s')) {
int stacksize = atoi(&argv[1][2]);
if (stacksize <= 0) {
- fprintf(stderr, "lua: invalid stack size ('%.20s')\n", &argv[1][2]);
+ fprintf(stderr, l_s("lua: invalid stack size ('%.20s')\n"), &argv[1][2]);
exit(EXIT_FAILURE);
}
opt->stacksize = stacksize;
@@ -306,10 +306,10 @@ static void getstacksize (int argc, char *argv[], struct Options *opt) {
}
-static void register_getargs (char *argv[]) {
+static void register_getargs (l_char *argv[]) {
lua_pushuserdata(L, argv);
lua_pushcclosure(L, l_getargs, 1);
- lua_setglobal(L, "getargs");
+ lua_setglobal(L, l_s("getargs"));
}
@@ -322,7 +322,7 @@ static void openstdlibs (lua_State *l) {
}
-int main (int argc, char *argv[]) {
+int main (int argc, l_char *argv[]) {
struct Options opt;
int status;
opt.toclose = 0;
diff --git a/lua.h b/lua.h
index 09221693..d786b025 100644
--- a/lua.h
+++ b/lua.h
@@ -1,5 +1,5 @@
/*
-** $Id: lua.h,v 1.87 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lua.h,v 1.88 2001/02/22 17:15:18 roberto Exp roberto $
** Lua - An Extensible Extension Language
** TeCGraf: Grupo de Tecnologia em Computacao Grafica, PUC-Rio, Brazil
** e-mail: lua@tecgraf.puc-rio.br
@@ -79,6 +79,8 @@ typedef int (*lua_CFunction) (lua_State *L);
/* Lua numerical type */
typedef double lua_Number;
+/* Lua character type */
+typedef char l_char;
/* mark for all API functions */
@@ -111,8 +113,8 @@ LUA_API int lua_stackspace (lua_State *L);
*/
LUA_API int lua_type (lua_State *L, int index);
-LUA_API const char *lua_typename (lua_State *L, int t);
-LUA_API const char *lua_xtype (lua_State *L, int index);
+LUA_API const l_char *lua_typename (lua_State *L, int t);
+LUA_API const l_char *lua_xtype (lua_State *L, int index);
LUA_API int lua_isnumber (lua_State *L, int index);
LUA_API int lua_isstring (lua_State *L, int index);
LUA_API int lua_iscfunction (lua_State *L, int index);
@@ -122,7 +124,7 @@ LUA_API int lua_equal (lua_State *L, int index1, int index2);
LUA_API int lua_lessthan (lua_State *L, int index1, int index2);
LUA_API lua_Number lua_tonumber (lua_State *L, int index);
-LUA_API const char *lua_tostring (lua_State *L, int index);
+LUA_API const l_char *lua_tostring (lua_State *L, int index);
LUA_API size_t lua_strlen (lua_State *L, int index);
LUA_API lua_CFunction lua_tocfunction (lua_State *L, int index);
LUA_API void *lua_touserdata (lua_State *L, int index);
@@ -134,8 +136,8 @@ LUA_API const void *lua_topointer (lua_State *L, int index);
*/
LUA_API void lua_pushnil (lua_State *L);
LUA_API void lua_pushnumber (lua_State *L, lua_Number n);
-LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len);
-LUA_API void lua_pushstring (lua_State *L, const char *s);
+LUA_API void lua_pushlstring (lua_State *L, const l_char *s, size_t len);
+LUA_API void lua_pushstring (lua_State *L, const l_char *s);
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
LUA_API int lua_pushuserdata (lua_State *L, void *u);
@@ -143,12 +145,12 @@ LUA_API int lua_pushuserdata (lua_State *L, void *u);
/*
** get functions (Lua -> stack)
*/
-LUA_API void lua_getglobal (lua_State *L, const char *name);
+LUA_API void lua_getglobal (lua_State *L, const l_char *name);
LUA_API void lua_gettable (lua_State *L, int index);
LUA_API void lua_rawget (lua_State *L, int index);
LUA_API void lua_rawgeti (lua_State *L, int index, int n);
LUA_API void lua_getglobals (lua_State *L);
-LUA_API void lua_gettagmethod (lua_State *L, int tag, const char *event);
+LUA_API void lua_gettagmethod (lua_State *L, int tag, const l_char *event);
LUA_API int lua_getref (lua_State *L, int ref);
LUA_API void lua_newtable (lua_State *L);
@@ -156,23 +158,24 @@ LUA_API void lua_newtable (lua_State *L);
/*
** set functions (stack -> Lua)
*/
-LUA_API void lua_setglobal (lua_State *L, const char *name);
+LUA_API void lua_setglobal (lua_State *L, const l_char *name);
LUA_API void lua_settable (lua_State *L, int index);
LUA_API void lua_rawset (lua_State *L, int index);
LUA_API void lua_rawseti (lua_State *L, int index, int n);
LUA_API void lua_setglobals (lua_State *L);
-LUA_API void lua_settagmethod (lua_State *L, int tag, const char *event);
+LUA_API void lua_settagmethod (lua_State *L, int tag, const l_char *event);
LUA_API int lua_ref (lua_State *L, int lock);
/*
-** "do" functions (run Lua code)
+** `do' functions (run Lua code)
*/
LUA_API int lua_call (lua_State *L, int nargs, int nresults);
LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults);
-LUA_API int lua_dofile (lua_State *L, const char *filename);
-LUA_API int lua_dostring (lua_State *L, const char *str);
-LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, const char *name);
+LUA_API int lua_dofile (lua_State *L, const l_char *filename);
+LUA_API int lua_dostring (lua_State *L, const l_char *str);
+LUA_API int lua_dobuffer (lua_State *L, const l_char *buff, size_t size,
+ const l_char *name);
/*
** Garbage-collection functions
@@ -184,12 +187,12 @@ LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold);
/*
** miscellaneous functions
*/
-LUA_API int lua_newtype (lua_State *L, const char *name, int basictype);
-LUA_API int lua_type2tag (lua_State *L, const char *name);
+LUA_API int lua_newtype (lua_State *L, const l_char *name, int basictype);
+LUA_API int lua_type2tag (lua_State *L, const l_char *name);
LUA_API int lua_copytagmethods (lua_State *L, int tagto, int tagfrom);
LUA_API void lua_settag (lua_State *L, int tag);
-LUA_API void lua_error (lua_State *L, const char *s);
+LUA_API void lua_error (lua_State *L, const l_char *s);
LUA_API void lua_unref (lua_State *L, int ref);
@@ -222,8 +225,8 @@ LUA_API void *lua_newuserdata (lua_State *L, size_t size);
#define lua_getregistry(L) lua_getref(L, LUA_REFREGISTRY)
-#define lua_pushliteral(L, s) lua_pushlstring(L, "" s, \
- (sizeof(s)/sizeof(char))-1)
+#define lua_pushliteral(L, s) lua_pushlstring(L, l_s("") s, \
+ (sizeof(s)/sizeof(l_char))-1)
diff --git a/luadebug.h b/luadebug.h
index 72994165..5ffdbe03 100644
--- a/luadebug.h
+++ b/luadebug.h
@@ -1,5 +1,5 @@
/*
-** $Id: luadebug.h,v 1.16 2000/10/20 16:39:03 roberto Exp roberto $
+** $Id: luadebug.h,v 1.17 2000/10/30 12:38:50 roberto Exp roberto $
** Debugging API
** See Copyright Notice in lua.h
*/
@@ -18,9 +18,9 @@ typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API int lua_getinfo (lua_State *L, const l_char *what, lua_Debug *ar);
+LUA_API const l_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func);
LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func);
@@ -29,15 +29,15 @@ LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func);
#define LUA_IDSIZE 60
struct lua_Debug {
- const char *event; /* `call', `return' */
+ const l_char *event; /* `call', `return' */
int currentline; /* (l) */
- const char *name; /* (n) */
- const char *namewhat; /* (n) `global', `tag method', `local', `field' */
+ const l_char *name; /* (n) */
+ const l_char *namewhat; /* (n) `global', `tag method', `local', `field' */
int nups; /* (u) number of upvalues */
int linedefined; /* (S) */
- const char *what; /* (S) `Lua' function, `C' function, Lua `main' */
- const char *source; /* (S) */
- char short_src[LUA_IDSIZE]; /* (S) */
+ const l_char *what; /* (S) `Lua' function, `C' function, Lua `main' */
+ const l_char *source; /* (S) */
+ l_char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
struct lua_TObject *_func; /* active function */
};
diff --git a/lualib.h b/lualib.h
index aea9ee08..60fc3788 100644
--- a/lualib.h
+++ b/lualib.h
@@ -1,5 +1,5 @@
/*
-** $Id: lualib.h,v 1.15 2000/11/23 13:49:35 roberto Exp roberto $
+** $Id: lualib.h,v 1.16 2001/02/22 17:15:18 roberto Exp roberto $
** Lua standard libraries
** See Copyright Notice in lua.h
*/
@@ -36,4 +36,14 @@ LUALIB_API void lua_dblibopen (lua_State *L);
/* integer type to hold the result of fgetc */
typedef int l_charint;
+/* macro to control type of literal strings */
+#ifndef l_s
+#define l_s(x) x
+#endif
+
+/* macro to control type of literal chars */
+#ifndef l_c
+#define l_c(x) x
+#endif
+
#endif
diff --git a/lundump.c b/lundump.c
index 1711e4f0..353e746e 100644
--- a/lundump.c
+++ b/lundump.c
@@ -1,5 +1,5 @@
/*
-** $Id: lundump.c,v 1.37 2000/12/28 12:59:41 roberto Exp roberto $
+** $Id: lundump.c,v 1.38 2001/01/15 16:13:24 roberto Exp roberto $
** load bytecodes from files
** See Copyright Notice in lua.h
*/
@@ -15,15 +15,15 @@
#define LoadByte ezgetc
-static const char* ZNAME (ZIO* Z)
+static const l_char* ZNAME (ZIO* Z)
{
- const char* s=zname(Z);
- return (*s=='@') ? s+1 : s;
+ const l_char* s=zname(Z);
+ return (*s==l_c('@')) ? s+1 : s;
}
static void unexpectedEOZ (lua_State* L, ZIO* Z)
{
- luaO_verror(L,"unexpected end of file in `%.99s'",ZNAME(Z));
+ luaO_verror(L,l_s("unexpected end of file in `%.99s'"),ZNAME(Z));
}
static int ezgetc (lua_State* L, ZIO* Z)
@@ -43,9 +43,9 @@ static void LoadBlock (lua_State* L, void* b, size_t size, ZIO* Z, int swap)
{
if (swap)
{
- char *p=(char *) b+size-1;
+ l_char *p=(l_char *) b+size-1;
int n=size;
- while (n--) *p--=(char)ezgetc(L,Z);
+ while (n--) *p--=(l_char)ezgetc(L,Z);
}
else
ezread(L,Z,b,size);
@@ -55,12 +55,12 @@ static void LoadVector (lua_State* L, void* b, int m, size_t size, ZIO* Z, int s
{
if (swap)
{
- char *q=(char *) b;
+ l_char *q=(l_char *) b;
while (m--)
{
- char *p=q+size-1;
+ l_char *p=q+size-1;
int n=size;
- while (n--) *p--=(char)ezgetc(L,Z);
+ while (n--) *p--=(l_char)ezgetc(L,Z);
q+=size;
}
}
@@ -96,9 +96,9 @@ static TString* LoadString (lua_State* L, ZIO* Z, int swap)
return NULL;
else
{
- char* s=luaO_openspace(L,size);
+ l_char* s=luaO_openspace(L,size);
LoadBlock(L,s,size,Z,0);
- return luaS_newlstr(L,s,size-1); /* remove trailing '\0' */
+ return luaS_newlstr(L,s,size-1); /* remove trailing l_c('\0') */
}
}
@@ -171,18 +171,18 @@ static Proto* LoadFunction (lua_State* L, ZIO* Z, int swap)
static void LoadSignature (lua_State* L, ZIO* Z)
{
- const char* s=SIGNATURE;
+ const l_char* s=SIGNATURE;
while (*s!=0 && ezgetc(L,Z)==*s)
++s;
- if (*s!=0) luaO_verror(L,"bad signature in `%.99s'",ZNAME(Z));
+ if (*s!=0) luaO_verror(L,l_s("bad signature in `%.99s'"),ZNAME(Z));
}
-static void TestSize (lua_State* L, int s, const char* what, ZIO* Z)
+static void TestSize (lua_State* L, int s, const l_char* what, ZIO* Z)
{
int r=ezgetc(L,Z);
if (r!=s)
- luaO_verror(L,"virtual machine mismatch in `%.99s':\n"
- " %.20s is %d but read %d",ZNAME(Z),what,s,r);
+ luaO_verror(L,l_s("virtual machine mismatch in `%.99s':\n")
+ l_s(" %.20s is %d but read %d"),ZNAME(Z),what,s,r);
}
#define TESTSIZE(s) TestSize(L,s,#s,Z)
@@ -195,12 +195,12 @@ static int LoadHeader (lua_State* L, ZIO* Z)
LoadSignature(L,Z);
version=ezgetc(L,Z);
if (version>VERSION)
- luaO_verror(L,"`%.99s' too new:\n"
- " read version %d.%d; expected at most %d.%d",
+ luaO_verror(L,l_s("`%.99s' too new:\n")
+ l_s(" read version %d.%d; expected at most %d.%d"),
ZNAME(Z),V(version),V(VERSION));
if (version<VERSION0) /* check last major change */
- luaO_verror(L,"`%.99s' too old:\n"
- " read version %d.%d; expected at least %d.%d",
+ luaO_verror(L,l_s("`%.99s' too old:\n")
+ l_s(" read version %d.%d; expected at least %d.%d"),
ZNAME(Z),V(version),V(VERSION));
swap=(luaU_endianess()!=ezgetc(L,Z)); /* need to swap bytes? */
TESTSIZE(sizeof(int));
@@ -212,8 +212,8 @@ static int LoadHeader (lua_State* L, ZIO* Z)
TESTSIZE(sizeof(lua_Number));
f=LoadNumber(L,Z,swap);
if ((long)f!=(long)tf) /* disregard errors in last bit of fraction */
- luaO_verror(L,"unknown number format in `%.99s':\n"
- " read " NUMBER_FMT "; expected " NUMBER_FMT, ZNAME(Z),f,tf);
+ luaO_verror(L,l_s("unknown number format in `%.99s':\n")
+ l_s(" read ") NUMBER_FMT l_s("; expected ") NUMBER_FMT, ZNAME(Z),f,tf);
return swap;
}
@@ -234,7 +234,7 @@ Proto* luaU_undump (lua_State* L, ZIO* Z)
tf=LoadChunk(L,Z);
c=zgetc(Z);
if (c!=EOZ)
- luaO_verror(L,"`%.99s' apparently contains more than one chunk",ZNAME(Z));
+ luaO_verror(L,l_s("`%.99s' apparently contains more than one chunk"),ZNAME(Z));
return tf;
}
@@ -244,5 +244,5 @@ Proto* luaU_undump (lua_State* L, ZIO* Z)
int luaU_endianess (void)
{
int x=1;
- return *(char*)&x;
+ return *(l_char*)&x;
}
diff --git a/lundump.h b/lundump.h
index 446d2de9..19bef569 100644
--- a/lundump.h
+++ b/lundump.h
@@ -1,5 +1,5 @@
/*
-** $Id: lundump.h,v 1.21 2000/10/31 16:57:23 lhf Exp $
+** $Id: lundump.h,v 1.19 2000/11/07 12:44:44 roberto Exp roberto $
** load pre-compiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -20,12 +20,12 @@ int luaU_endianess (void);
#define VERSION 0x40 /* last format change was in 4.0 */
#define VERSION0 0x40 /* last major change was in 4.0 */
#define ID_CHUNK 27 /* binary files start with ESC... */
-#define SIGNATURE "Lua" /* ...followed by this signature */
+#define SIGNATURE l_s("Lua") /* ...followed by this signature */
/* formats for error messages */
-#define SOURCE_FMT "<%d:%.99s>"
+#define SOURCE_FMT l_s("<%d:%.99s>")
#define SOURCE tf->lineDefined,tf->source->str
-#define IN_FMT " in %p " SOURCE_FMT
+#define IN_FMT l_s(" in %p ") SOURCE_FMT
#define IN tf,SOURCE
/* a multiple of PI for testing native format */
diff --git a/lvm.c b/lvm.c
index 8db50ad7..620cc979 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
/*
-** $Id: lvm.c,v 1.170 2001/02/20 18:15:33 roberto Exp roberto $
+** $Id: lvm.c,v 1.171 2001/02/22 18:59:59 roberto Exp roberto $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
@@ -43,7 +43,7 @@ int luaV_tostring (lua_State *L, TObject *obj) { /* LUA_NUMBER */
if (ttype(obj) != LUA_TNUMBER)
return 1;
else {
- char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */
+ l_char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */
lua_number2str(s, nvalue(obj)); /* convert `s' to number */
setsvalue(obj, luaS_new(L, s));
return 0;
@@ -96,23 +96,23 @@ void luaV_Lclosure (lua_State *L, Proto *l, int nelems) {
}
-static void callTM (lua_State *L, const char *fmt, ...) {
+static void callTM (lua_State *L, const l_char *fmt, ...) {
va_list argp;
StkId base = L->top;
int has_result = 0;
va_start(argp, fmt);
while (*fmt) {
switch (*fmt++) {
- case 'c':
+ case l_c('c'):
setclvalue(L->top, va_arg(argp, Closure *));
break;
- case 'o':
+ case l_c('o'):
setobj(L->top, va_arg(argp, TObject *));
break;
- case 's':
+ case l_c('s'):
setsvalue(L->top, va_arg(argp, TString *));
break;
- case 'r':
+ case l_c('r'):
has_result = 1;
continue;
}
@@ -151,9 +151,9 @@ void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res) {
else { /* not a table; try a `gettable' tag method */
tm = luaT_gettmbyObj(G(L), t, TM_GETTABLE);
if (tm == NULL) /* no tag method? */
- luaG_typeerror(L, t, "index");
+ luaG_typeerror(L, t, l_s("index"));
}
- callTM(L, "coor", tm, t, key, res);
+ callTM(L, l_s("coor"), tm, t, key, res);
}
@@ -175,9 +175,9 @@ void luaV_settable (lua_State *L, StkId t, StkId key, StkId val) {
else { /* not a table; try a `settable' tag method */
tm = luaT_gettmbyObj(G(L), t, TM_SETTABLE);
if (tm == NULL) /* no tag method? */
- luaG_typeerror(L, t, "index");
+ luaG_typeerror(L, t, l_s("index"));
}
- callTM(L, "cooo", tm, t, key, val);
+ callTM(L, l_s("cooo"), tm, t, key, val);
}
@@ -189,7 +189,7 @@ void luaV_getglobal (lua_State *L, TString *name, StkId res) {
setobj(res, value); /* default behavior */
}
else
- callTM(L, "csor", tm, name, value, res);
+ callTM(L, l_s("csor"), tm, name, value, res);
}
@@ -201,7 +201,7 @@ void luaV_setglobal (lua_State *L, TString *name, StkId val) {
setobj(oldvalue, val); /* raw set */
}
else
- callTM(L, "csoo", tm, name, oldvalue, val);
+ callTM(L, l_s("csoo"), tm, name, oldvalue, val);
}
@@ -218,21 +218,21 @@ static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2,
}
}
opname = luaS_new(L, luaT_eventname[event]);
- callTM(L, "coosr", tm, p1, p2, opname, res);
+ callTM(L, l_s("coosr"), tm, p1, p2, opname, res);
return 1;
}
static void call_arith (lua_State *L, StkId p1, TMS event) {
if (!call_binTM(L, p1, p1+1, p1, event))
- luaG_binerror(L, p1, LUA_TNUMBER, "perform arithmetic on");
+ luaG_binerror(L, p1, LUA_TNUMBER, l_s("perform arithmetic on"));
}
static int luaV_strlessthan (const TString *ls, const TString *rs) {
- const char *l = getstr(ls);
+ const l_char *l = getstr(ls);
size_t ll = ls->len;
- const char *r = getstr(rs);
+ const l_char *r = getstr(rs);
size_t lr = rs->len;
for (;;) {
int temp = strcoll(l, r);
@@ -269,18 +269,18 @@ void luaV_strconc (lua_State *L, int total, StkId top) {
int n = 2; /* number of elements handled in this pass (at least 2) */
if (tostring(L, top-2) || tostring(L, top-1)) {
if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
- luaG_binerror(L, top-2, LUA_TSTRING, "concat");
+ luaG_binerror(L, top-2, LUA_TSTRING, l_s("concat"));
}
else if (tsvalue(top-1)->len > 0) { /* if len=0, do nothing */
/* at least two string values; get as many as possible */
lu_mem tl = (lu_mem)tsvalue(top-1)->len + (lu_mem)tsvalue(top-2)->len;
- char *buffer;
+ l_char *buffer;
int i;
while (n < total && !tostring(L, top-n-1)) { /* collect total length */
tl += tsvalue(top-n-1)->len;
n++;
}
- if (tl > MAX_SIZET) luaD_error(L, "string size overflow");
+ if (tl > MAX_SIZET) luaD_error(L, l_s("string size overflow"));
buffer = luaO_openspace(L, tl);
tl = 0;
for (i=n; i>0; i--) { /* concat all strings */
@@ -303,7 +303,7 @@ static void luaV_pack (lua_State *L, StkId firstelem) {
for (i=0; firstelem+i<L->top; i++)
setobj(luaH_setnum(L, htab, i+1), firstelem+i);
/* store counter in field `n' */
- n = luaH_setstr(L, htab, luaS_newliteral(L, "n"));
+ n = luaH_setstr(L, htab, luaS_newliteral(L, l_s("n")));
setnvalue(n, i);
L->top = firstelem; /* remove elements from the stack */
sethvalue(L->top, htab);
@@ -509,7 +509,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
}
case OP_POW: {
if (!call_binTM(L, top-2, top-1, top-2, TM_POW))
- luaD_error(L, "undefined operation");
+ luaD_error(L, l_s("undefined operation"));
top--;
break;
}
@@ -595,11 +595,11 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
case OP_FORPREP: {
int jmp = GETARG_S(i);
if (tonumber(top-1))
- luaD_error(L, "`for' step must be a number");
+ luaD_error(L, l_s("`for' step must be a number"));
if (tonumber(top-2))
- luaD_error(L, "`for' limit must be a number");
+ luaD_error(L, l_s("`for' limit must be a number"));
if (tonumber(top-3))
- luaD_error(L, "`for' initial value must be a number");
+ luaD_error(L, l_s("`for' initial value must be a number"));
pc += -jmp; /* `jump' to loop end (delta is negated here) */
goto forloop; /* do not increment index */
}
@@ -607,7 +607,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
lua_assert(ttype(top-1) == LUA_TNUMBER);
lua_assert(ttype(top-2) == LUA_TNUMBER);
if (ttype(top-3) != LUA_TNUMBER)
- luaD_error(L, "`for' index must be a number");
+ luaD_error(L, l_s("`for' index must be a number"));
nvalue(top-3) += nvalue(top-1); /* increment index */
forloop:
if (nvalue(top-1) > 0 ?
@@ -621,7 +621,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
case OP_LFORPREP: {
int jmp = GETARG_S(i);
if (ttype(top-1) != LUA_TTABLE)
- luaD_error(L, "`for' table must be a table");
+ luaD_error(L, l_s("`for' table must be a table"));
top += 3; /* index,key,value */
setnvalue(top-3, -1); /* initial index */
setnilvalue(top-2);
--
cgit v1.2.3-55-g6feb