diff --git a/lapi.c b/lapi.c index 23488256..02d8e62d 100644 --- a/lapi.c +++ b/lapi.c @@ -1,5 +1,5 @@ /* -** $Id: lapi.c,v 2.28 2005/02/23 17:30:22 roberto Exp roberto $ +** $Id: lapi.c,v 2.29 2005/03/08 18:09:16 roberto Exp roberto $ ** Lua API ** See Copyright Notice in lua.h */ @@ -95,7 +95,7 @@ void luaA_pushobject (lua_State *L, const TValue *o) { LUA_API int lua_checkstack (lua_State *L, int size) { int res; lua_lock(L); - if ((L->top - L->base + size) > MAXCSTACK) + if ((L->top - L->base + size) > LUAC_MAXCSTACK) res = 0; /* stack overflow */ else { luaD_checkstack(L, size); diff --git a/lcode.c b/lcode.c index d2f05a8d..07d1b4f4 100644 --- a/lcode.c +++ b/lcode.c @@ -1,5 +1,5 @@ /* -** $Id: lcode.c,v 2.8 2004/12/03 20:35:33 roberto Exp roberto $ +** $Id: lcode.c,v 2.9 2005/01/10 18:17:39 roberto Exp roberto $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -606,7 +606,7 @@ void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) { if (op == OPR_MINUS) { luaK_exp2val(fs, e); if (e->k == VK && ttisnumber(&fs->f->k[e->info])) - e->info = luaK_numberK(fs, num_unm(nvalue(&fs->f->k[e->info]))); + e->info = luaK_numberK(fs, luac_numunm(nvalue(&fs->f->k[e->info]))); else { luaK_exp2anyreg(fs, e); freeexp(fs, e); diff --git a/ldblib.c b/ldblib.c index 1686339a..92ab8e63 100644 --- a/ldblib.c +++ b/ldblib.c @@ -1,5 +1,5 @@ /* -** $Id: ldblib.c,v 1.92 2005/01/18 17:23:25 roberto Exp roberto $ +** $Id: ldblib.c,v 1.93 2005/02/18 12:40:02 roberto Exp roberto $ ** Interface from Lua to its debug API ** See Copyright Notice in lua.h */ @@ -19,7 +19,7 @@ -static int getmetatable (lua_State *L) { +static int db_getmetatable (lua_State *L) { luaL_checkany(L, 1); if (!lua_getmetatable(L, 1)) { lua_pushnil(L); /* no metatable */ @@ -28,7 +28,7 @@ static int getmetatable (lua_State *L) { } -static int setmetatable (lua_State *L) { +static int db_setmetatable (lua_State *L) { int t = lua_type(L, 2); luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table expected"); @@ -38,13 +38,13 @@ static int setmetatable (lua_State *L) { } -static int getfenv (lua_State *L) { +static int db_getfenv (lua_State *L) { lua_getfenv(L, 1); return 1; } -static int setfenv (lua_State *L) { +static int db_setfenv (lua_State *L) { luaL_checktype(L, 2, LUA_TTABLE); lua_settop(L, 2); if (lua_setfenv(L, 1) == 0) @@ -77,7 +77,7 @@ static lua_State *getthread (lua_State *L, int *arg) { } -static int getinfo (lua_State *L) { +static int db_getinfo (lua_State *L) { lua_Debug ar; int arg; lua_State *L1 = getthread(L, &arg); @@ -130,7 +130,7 @@ static int getinfo (lua_State *L) { } -static int getlocal (lua_State *L) { +static int db_getlocal (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); lua_Debug ar; @@ -151,7 +151,7 @@ static int getlocal (lua_State *L) { } -static int setlocal (lua_State *L) { +static int db_setlocal (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); lua_Debug ar; @@ -178,12 +178,12 @@ static int auxupvalue (lua_State *L, int get) { } -static int getupvalue (lua_State *L) { +static int db_getupvalue (lua_State *L) { return auxupvalue(L, 1); } -static int setupvalue (lua_State *L) { +static int db_setupvalue (lua_State *L) { luaL_checkany(L, 3); return auxupvalue(L, 0); } @@ -244,7 +244,7 @@ static void gethooktable (lua_State *L) { } -static int sethook (lua_State *L) { +static int db_sethook (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); if (lua_isnoneornil(L, arg+1)) { @@ -267,7 +267,7 @@ static int sethook (lua_State *L) { } -static int gethook (lua_State *L) { +static int db_gethook (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); char buff[5]; @@ -288,7 +288,7 @@ static int gethook (lua_State *L) { } -static int debug (lua_State *L) { +static int db_debug (lua_State *L) { for (;;) { char buffer[250]; fputs("lua_debug> ", stderr); @@ -308,7 +308,7 @@ static int debug (lua_State *L) { #define LEVELS1 12 /* size of the first part of the stack */ #define LEVELS2 10 /* size of the second part of the stack */ -static int errorfb (lua_State *L) { +static int db_errorfb (lua_State *L) { int level; int firstpart = 1; /* still before eventual `...' */ int arg; @@ -362,19 +362,19 @@ static int errorfb (lua_State *L) { static const luaL_reg dblib[] = { - {"getmetatable", getmetatable}, - {"setmetatable", setmetatable}, - {"getfenv", getfenv}, - {"setfenv", setfenv}, - {"getlocal", getlocal}, - {"getinfo", getinfo}, - {"gethook", gethook}, - {"getupvalue", getupvalue}, - {"sethook", sethook}, - {"setlocal", setlocal}, - {"setupvalue", setupvalue}, - {"debug", debug}, - {"traceback", errorfb}, + {"getmetatable", db_getmetatable}, + {"setmetatable", db_setmetatable}, + {"getfenv", db_getfenv}, + {"setfenv", db_setfenv}, + {"getlocal", db_getlocal}, + {"getinfo", db_getinfo}, + {"gethook", db_gethook}, + {"getupvalue", db_getupvalue}, + {"sethook", db_sethook}, + {"setlocal", db_setlocal}, + {"setupvalue", db_setupvalue}, + {"debug", db_debug}, + {"traceback", db_errorfb}, {NULL, NULL} }; diff --git a/ldo.c b/ldo.c index cf1bd65a..94a75ed0 100644 --- a/ldo.c +++ b/ldo.c @@ -1,5 +1,5 @@ /* -** $Id: ldo.c,v 2.14 2005/02/18 12:40:02 roberto Exp roberto $ +** $Id: ldo.c,v 2.15 2005/03/08 18:09:16 roberto Exp roberto $ ** Stack and Call structure of Lua ** See Copyright Notice in lua.h */ @@ -43,7 +43,7 @@ /* chain list of long jump buffers */ struct lua_longjmp { struct lua_longjmp *previous; - l_jmpbuf b; + luac_jmpbuf b; volatile int status; /* error code */ }; @@ -71,7 +71,7 @@ static void seterrorobj (lua_State *L, int errcode, StkId oldtop) { void luaD_throw (lua_State *L, int errcode) { if (L->errorJmp) { L->errorJmp->status = errcode; - L_THROW(L, L->errorJmp); + LUAC_THROW(L, L->errorJmp); } else { if (G(L)->panic) G(L)->panic(L); @@ -85,7 +85,7 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { lj.status = 0; lj.previous = L->errorJmp; /* chain new error handler */ L->errorJmp = &lj; - L_TRY(L, &lj, + LUAC_TRY(L, &lj, (*f)(L, ud); ); L->errorJmp = lj.previous; /* restore old error handler */ @@ -95,10 +95,10 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { static void restore_stack_limit (lua_State *L) { lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1); - if (L->size_ci > LUA_MAXCALLS) { /* there was an overflow? */ + if (L->size_ci > LUAC_MAXCALLS) { /* there was an overflow? */ int inuse = (L->ci - L->base_ci); - if (inuse + 1 < LUA_MAXCALLS) /* can `undo' overflow? */ - luaD_reallocCI(L, LUA_MAXCALLS); + if (inuse + 1 < LUAC_MAXCALLS) /* can `undo' overflow? */ + luaD_reallocCI(L, LUAC_MAXCALLS); } } @@ -149,11 +149,11 @@ void luaD_growstack (lua_State *L, int n) { static CallInfo *growCI (lua_State *L) { - if (L->size_ci > LUA_MAXCALLS) /* overflow while handling overflow? */ + if (L->size_ci > LUAC_MAXCALLS) /* overflow while handling overflow? */ luaD_throw(L, LUA_ERRERR); else { luaD_reallocCI(L, 2*L->size_ci); - if (L->size_ci > LUA_MAXCALLS) + if (L->size_ci > LUAC_MAXCALLS) luaG_runerror(L, "stack overflow"); } return ++L->ci; @@ -340,10 +340,10 @@ void luaD_poscall (lua_State *L, int wanted, StkId firstResult) { ** function position. */ void luaD_call (lua_State *L, StkId func, int nResults) { - if (++L->nCcalls >= LUA_MAXCCALLS) { - if (L->nCcalls == LUA_MAXCCALLS) + if (++L->nCcalls >= LUAC_MAXCCALLS) { + if (L->nCcalls == LUAC_MAXCCALLS) luaG_runerror(L, "C stack overflow"); - else if (L->nCcalls >= (LUA_MAXCCALLS + (LUA_MAXCCALLS>>3))) + else if (L->nCcalls >= (LUAC_MAXCCALLS + (LUAC_MAXCCALLS>>3))) luaD_throw(L, LUA_ERRERR); /* error while handing stack error */ } if (luaD_precall(L, func, nResults) == PCRLUA) { /* is a Lua function? */ diff --git a/lgc.c b/lgc.c index 5cbaa71a..714e2fff 100644 --- a/lgc.c +++ b/lgc.c @@ -1,5 +1,5 @@ /* -** $Id: lgc.c,v 2.26 2005/02/18 12:40:02 roberto Exp roberto $ +** $Id: lgc.c,v 2.27 2005/02/23 17:30:22 roberto Exp roberto $ ** Garbage Collector ** See Copyright Notice in lua.h */ @@ -242,7 +242,7 @@ static void traverseclosure (global_State *g, Closure *cl) { static void checkstacksizes (lua_State *L, StkId max) { int ci_used = L->ci - L->base_ci; /* number of `ci' in use */ int s_used = max - L->stack; /* part of stack in use */ - if (L->size_ci > LUA_MAXCALLS) /* handling overflow? */ + if (L->size_ci > LUAC_MAXCALLS) /* handling overflow? */ return; /* do not touch the stacks */ if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci) luaD_reallocCI(L, L->size_ci/2); /* still big enough... */ diff --git a/llimits.h b/llimits.h index 86b3f28f..52eacfc7 100644 --- a/llimits.h +++ b/llimits.h @@ -1,5 +1,5 @@ /* -** $Id: llimits.h,v 1.62 2004/12/13 12:15:11 roberto Exp roberto $ +** $Id: llimits.h,v 1.63 2005/01/14 14:19:42 roberto Exp roberto $ ** Limits, basic types, and some other `installation-dependent' definitions ** See Copyright Notice in lua.h */ @@ -15,12 +15,14 @@ #include "lua.h" +#define api_check luac_apicheck -typedef LUA_UINT32 lu_int32; -typedef LU_MEM lu_mem; +typedef LUAC_UINT32 lu_int32; -typedef L_MEM l_mem; +typedef LUAC_UMEM lu_mem; + +typedef LUAC_MEM l_mem; @@ -45,11 +47,11 @@ typedef unsigned char lu_byte; /* type to ensure maximum alignment */ -typedef LUSER_ALIGNMENT_T L_Umaxalign; +typedef LUAC_USER_ALIGNMENT_T L_Umaxalign; /* result of a `usual argument conversion' over lua_Number */ -typedef LUA_UACNUMBER l_uacNumber; +typedef LUAC_UACNUMBER l_uacNumber; #define check_exp(c,e) (lua_assert(c), (e)) diff --git a/loadlib.c b/loadlib.c index 21a6d0d8..545d062b 100644 --- a/loadlib.c +++ b/loadlib.c @@ -1,5 +1,5 @@ /* -** $Id: loadlib.c,v 1.18 2005/02/28 15:58:48 roberto Exp roberto $ +** $Id: loadlib.c,v 1.19 2005/03/07 18:07:34 roberto Exp roberto $ ** Dynamic library loader for Lua ** See Copyright Notice in lua.h * @@ -33,7 +33,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym); -#if defined(USE_DLOPEN) +#if defined(LUA_USEDLOPEN) /* ** {======================================================================== ** This is an implementation of loadlib based on the dlfcn interface. @@ -67,7 +67,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { -#elif defined(USE_DLL) +#elif defined(LUA_USEDLL) /* ** {====================================================================== ** This is an implementation of loadlib for Windows using native functions. @@ -109,7 +109,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { -#elif defined(USE_DYLD) +#elif defined(LUA_USEDYLD) /* ** {====================================================================== ** Native Mac OS X / Darwin Implementation @@ -119,6 +119,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { #include +/* Mac appends a `_' before C function names */ #undef POF #define POF "_" LUA_POF diff --git a/lobject.c b/lobject.c index 71607c34..82f37503 100644 --- a/lobject.c +++ b/lobject.c @@ -1,5 +1,5 @@ /* -** $Id: lobject.c,v 2.8 2005/01/10 18:17:39 roberto Exp roberto $ +** $Id: lobject.c,v 2.9 2005/03/08 18:09:16 roberto Exp roberto $ ** Some generic functions over Lua objects ** See Copyright Notice in lua.h */ @@ -74,7 +74,7 @@ int luaO_rawequalObj (const TValue *t1, const TValue *t2) { case LUA_TNIL: return 1; case LUA_TNUMBER: - return num_eq(nvalue(t1), nvalue(t2)); + return luac_numeq(nvalue(t1), nvalue(t2)); case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */ case LUA_TLIGHTUSERDATA: diff --git a/lopcodes.h b/lopcodes.h index c8bd6673..0754c1bc 100644 --- a/lopcodes.h +++ b/lopcodes.h @@ -1,5 +1,5 @@ /* -** $Id: lopcodes.h,v 1.114 2004/12/02 12:59:10 roberto Exp roberto $ +** $Id: lopcodes.h,v 1.115 2005/03/08 18:00:16 roberto Exp roberto $ ** Opcodes for Lua virtual machine ** See Copyright Notice in lua.h */ @@ -51,9 +51,9 @@ enum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */ /* ** limits for opcode arguments. ** we use (signed) int to manipulate most arguments, -** so they must fit in LUA_BITSINT-1 bits (-1 for sign) +** so they must fit in LUAC_BITSINT-1 bits (-1 for sign) */ -#if SIZE_Bx < LUA_BITSINT-1 +#if SIZE_Bx < LUAC_BITSINT-1 #define MAXARG_Bx ((1<>1) /* `sBx' is signed */ #else diff --git a/loslib.c b/loslib.c index 7dce9b26..8732e88f 100644 --- a/loslib.c +++ b/loslib.c @@ -1,5 +1,5 @@ /* -** $Id: loslib.c,v 1.3 2004/10/08 18:57:16 roberto Exp roberto $ +** $Id: loslib.c,v 1.4 2005/01/10 19:16:29 roberto Exp roberto $ ** Standard Operating System library ** See Copyright Notice in lua.h */ @@ -57,7 +57,7 @@ static int io_rename (lua_State *L) { static int io_tmpname (lua_State *L) { -#if !USE_TMPNAME +#if !LUA_USETMPNAME luaL_error(L, "`tmpname' not supported"); return 0; #else diff --git a/lparser.c b/lparser.c index 9246d44f..373dbeaa 100644 --- a/lparser.c +++ b/lparser.c @@ -1,5 +1,5 @@ /* -** $Id: lparser.c,v 2.15 2005/03/08 18:00:16 roberto Exp roberto $ +** $Id: lparser.c,v 2.16 2005/03/08 18:16:45 roberto Exp roberto $ ** Lua Parser ** See Copyright Notice in lua.h */ @@ -33,7 +33,7 @@ #define luaY_checklimit(fs,v,l,m) if ((v)>(l)) errorlimit(fs,l,m) -#define enterlevel(ls) if (++(ls)->nestlevel > LUA_MAXPARSERLEVEL) \ +#define enterlevel(ls) if (++(ls)->nestlevel > LUAC_MAXPARSERLEVEL) \ luaX_lexerror(ls, "chunk has too many syntax levels", 0) #define leavelevel(ls) ((ls)->nestlevel--) @@ -181,7 +181,7 @@ static int registerlocalvar (LexState *ls, TString *varname) { static void new_localvar (LexState *ls, TString *name, int n) { FuncState *fs = ls->fs; - luaY_checklimit(fs, fs->nactvar+n+1, MAXVARS, "local variables"); + luaY_checklimit(fs, fs->nactvar+n+1, LUAC_MAXVARS, "local variables"); fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name)); } @@ -213,7 +213,7 @@ static int indexupvalue (FuncState *fs, TString *name, expdesc *v) { } } /* new one */ - luaY_checklimit(fs, f->nups + 1, MAXUPVALUES, "upvalues"); + luaY_checklimit(fs, f->nups + 1, LUAC_MAXUPVALUES, "upvalues"); luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues, TString *, MAX_INT, ""); while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL; @@ -993,7 +993,7 @@ static int cond (LexState *ls) { static void whilestat (LexState *ls, int line) { /* whilestat -> WHILE cond DO block END */ - Instruction codeexp[MAXEXPWHILE + EXTRAEXP]; + Instruction codeexp[LUAC_MAXEXPWHILE + EXTRAEXP]; int lineexp; int i; int sizeexp; @@ -1011,7 +1011,7 @@ static void whilestat (LexState *ls, int line) { luaK_concat(fs, &v.f, fs->jpc); fs->jpc = NO_JUMP; sizeexp = fs->pc - expinit; /* size of expression code */ - if (sizeexp > MAXEXPWHILE) + if (sizeexp > LUAC_MAXEXPWHILE) luaX_syntaxerror(ls, "`while' condition too complex"); for (i = 0; i < sizeexp; i++) /* save `exp' code */ codeexp[i] = fs->f->code[expinit + i]; diff --git a/lparser.h b/lparser.h index 1b7cc524..1644ddd9 100644 --- a/lparser.h +++ b/lparser.h @@ -1,5 +1,5 @@ /* -** $Id: lparser.h,v 1.51 2004/05/31 18:51:50 roberto Exp roberto $ +** $Id: lparser.h,v 1.52 2005/03/07 16:58:27 roberto Exp roberto $ ** Lua Parser ** See Copyright Notice in lua.h */ @@ -67,8 +67,8 @@ typedef struct FuncState { int np; /* number of elements in `p' */ short nlocvars; /* number of elements in `locvars' */ lu_byte nactvar; /* number of active local variables */ - upvaldesc upvalues[MAXUPVALUES]; /* upvalues */ - unsigned short actvar[MAXVARS]; /* declared-variable stack */ + upvaldesc upvalues[LUAC_MAXUPVALUES]; /* upvalues */ + unsigned short actvar[LUAC_MAXVARS]; /* declared-variable stack */ } FuncState; diff --git a/lstrlib.c b/lstrlib.c index f66e56ae..ebe27d35 100644 --- a/lstrlib.c +++ b/lstrlib.c @@ -1,5 +1,5 @@ /* -** $Id: lstrlib.c,v 1.108 2004/11/19 16:58:43 roberto Exp roberto $ +** $Id: lstrlib.c,v 1.109 2004/12/01 15:46:06 roberto Exp roberto $ ** Standard library for string operations and pattern-matching ** See Copyright Notice in lua.h */ @@ -172,7 +172,7 @@ typedef struct MatchState { struct { const char *init; ptrdiff_t len; - } capture[MAX_CAPTURES]; + } capture[LUA_MAXCAPTURES]; } MatchState; @@ -327,7 +327,7 @@ static const char *start_capture (MatchState *ms, const char *s, const char *p, int what) { const char *res; int level = ms->level; - if (level >= MAX_CAPTURES) luaL_error(ms->L, "too many captures"); + if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures"); ms->capture[level].init = s; ms->capture[level].len = what; ms->level = level+1; diff --git a/ltable.c b/ltable.c index d9c43a7f..4d89b72c 100644 --- a/ltable.c +++ b/ltable.c @@ -1,5 +1,5 @@ /* -** $Id: ltable.c,v 2.15 2005/01/10 18:17:39 roberto Exp roberto $ +** $Id: ltable.c,v 2.16 2005/03/08 18:09:16 roberto Exp roberto $ ** Lua tables (hash) ** See Copyright Notice in lua.h */ @@ -38,10 +38,10 @@ /* ** max size of array part is 2^MAXBITS */ -#if LUA_BITSINT > 26 +#if LUAC_BITSINT > 26 #define MAXBITS 26 #else -#define MAXBITS (LUA_BITSINT-2) +#define MAXBITS (LUAC_BITSINT-2) #endif #define MAXASIZE (1 << MAXBITS) @@ -120,7 +120,7 @@ static int arrayindex (const TValue *key) { lua_Number n = nvalue(key); int k; lua_number2int(k, n); - if (num_eq(cast(lua_Number, k), nvalue(key))) + if (luac_numeq(cast(lua_Number, k), nvalue(key))) return k; } return -1; /* `key' did not match some condition */ @@ -437,7 +437,7 @@ const TValue *luaH_getnum (Table *t, int key) { lua_Number nk = cast(lua_Number, key); Node *n = hashnum(t, nk); do { /* check whether `key' is somewhere in the chain */ - if (ttisnumber(gkey(n)) && num_eq(nvalue(gkey(n)), nk)) + if (ttisnumber(gkey(n)) && luac_numeq(nvalue(gkey(n)), nk)) return gval(n); /* that's it */ else n = gnext(n); } while (n); @@ -470,7 +470,7 @@ const TValue *luaH_get (Table *t, const TValue *key) { case LUA_TNUMBER: { int k; lua_number2int(k, (nvalue(key))); - if (num_eq(cast(lua_Number, k), nvalue(key))) /* is an integer index? */ + if (luac_numeq(cast(lua_Number, k), nvalue(key))) /* index is integer? */ return luaH_getnum(t, k); /* use specialized version */ /* else go through */ } @@ -494,7 +494,7 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) { return cast(TValue *, p); else { if (ttisnil(key)) luaG_runerror(L, "table index is nil"); - else if (ttisnumber(key) && !num_eq(nvalue(key), nvalue(key))) + else if (ttisnumber(key) && !luac_numeq(nvalue(key), nvalue(key))) luaG_runerror(L, "table index is NaN"); return newkey(L, t, key); } diff --git a/luaconf.h b/luaconf.h index 62665d0d..73091967 100644 --- a/luaconf.h +++ b/luaconf.h @@ -1,5 +1,5 @@ /* -** $Id: luaconf.h,v 1.32 2005/03/08 18:00:16 roberto Exp roberto $ +** $Id: luaconf.h,v 1.33 2005/03/08 18:09:16 roberto Exp roberto $ ** Configuration file for Lua ** See Copyright Notice in lua.h */ @@ -30,7 +30,7 @@ ** ======================================================= */ -/* default path */ +/* CONFIG: default path */ #if defined(_WIN32) #define LUA_ROOT "C:\\Program Files\\Lua51" #define LUA_LDIR LUA_ROOT "\\lua" @@ -51,33 +51,58 @@ #endif +/* CONFIG: directory separator (for submodules) */ +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif -/* type of numbers in Lua */ + +/* CONFIG: environment variables that hold the search path for packages */ +#define LUA_PATH "LUA_PATH" +#define LUA_CPATH "LUA_CPATH" + +/* CONFIG: prefix for open functions in C libraries */ +#define LUA_POF "luaopen_" + +/* CONFIG: separator for open functions in C libraries */ +#define LUA_OFSEP "_" + +/* CONFIG: separator of templates in a path */ +#define LUA_PATHSEP ';' + +/* CONFIG: wild char in each template */ +#define LUA_PATH_MARK "?" + + + +/* CONFIG: type of numbers in Lua */ #define LUA_NUMBER double -/* formats for Lua numbers */ +/* CONFIG: formats for Lua numbers */ #define LUA_NUMBER_SCAN "%lf" #define LUA_NUMBER_FMT "%.14g" /* -** type for integer functions +** CONFIG: type for integer functions ** on most machines, `ptrdiff_t' gives a reasonable size for integers */ #define LUA_INTEGER ptrdiff_t -/* mark for all API functions */ +/* CONFIG: mark for all API functions */ #define LUA_API extern -/* mark for auxlib functions */ +/* CONFIG: mark for auxlib functions */ #define LUALIB_API extern -/* buffer size used by lauxlib buffer system */ +/* CONFIG: buffer size used by lauxlib buffer system */ #define LUAL_BUFFERSIZE BUFSIZ -/* assertions in Lua (mainly for internal debugging) */ +/* CONFIG: assertions in Lua (mainly for internal debugging) */ #define lua_assert(c) ((void)0) /* }====================================================== */ @@ -92,7 +117,7 @@ #ifdef lua_c -/* definition of `isatty' */ +/* CONFIG: definition of `isatty' */ #ifdef _POSIX_C_SOURCE #include #define stdin_is_tty() isatty(0) @@ -113,7 +138,7 @@ /* -** this macro can be used by some `history' system to save lines +** CONFIG: this macro can be used by some `history' system to save lines ** read in manual input */ #define lua_saveline(L,line) /* empty */ @@ -126,86 +151,80 @@ -/* -** {====================================================== -** Core configuration -** ======================================================= -*/ - -#ifdef LUA_CORE - -/* LUA-C API assertions */ -#define api_check(L,o) lua_assert(o) +/* CONFIG: LUA-C API assertions */ +#define luac_apicheck(L,o) lua_assert(o) /* number of bits in an `int' */ /* avoid overflows in comparison */ #if INT_MAX-20 < 32760 -#define LUA_BITSINT 16 +#define LUAC_BITSINT 16 #elif INT_MAX > 2147483640L /* `int' has at least 32 bits */ -#define LUA_BITSINT 32 +#define LUAC_BITSINT 32 #else #error "you must define LUA_BITSINT with number of bits in an integer" #endif /* -** L_UINT32: unsigned integer with at least 32 bits -** L_INT32: signed integer with at least 32 bits -** LU_MEM: an unsigned integer big enough to count the total memory used by Lua -** L_MEM: a signed integer big enough to count the total memory used by Lua +** CONFIG: +** LUAC_UINT32: unsigned integer with at least 32 bits +** LUAC_INT32: signed integer with at least 32 bits +** LUAC_UMEM: an unsigned integer big enough to count the total memory +** used by Lua +** LUAC_MEM: a signed integer big enough to count the total memory used by Lua */ -#if LUA_BITSINT >= 32 -#define LUA_UINT32 unsigned int -#define LUA_INT32 int -#define LUA_MAXINT32 INT_MAX -#define LU_MEM size_t -#define L_MEM ptrdiff_t +#if LUAC_BITSINT >= 32 +#define LUAC_UINT32 unsigned int +#define LUAC_INT32 int +#define LUAC_MAXINT32 INT_MAX +#define LUAC_UMEM size_t +#define LUAC_MEM ptrdiff_t #else /* 16-bit ints */ -#define LUA_UINT32 unsigned long -#define LUA_INT32 long -#define LUA_MAXINT32 LONG_MAX -#define LU_MEM LUA_UINT32 -#define L_MEM ptrdiff_t +#define LUAC_UINT32 unsigned long +#define LUAC_INT32 long +#define LUAC_MAXINT32 LONG_MAX +#define LUAC_UMEM LUAC_UINT32 +#define LUAC_MEM ptrdiff_t #endif -/* maximum depth for calls (unsigned short) */ -#define LUA_MAXCALLS 10000 +/* CONFIG: maximum depth for calls (unsigned short) */ +#define LUAC_MAXCALLS 10000 /* -** maximum depth for C calls (unsigned short): Not too big, or may +** CONFIG: maximum depth for C calls (unsigned short): Not too big, or may ** overflow the C stack... */ -#define LUA_MAXCCALLS 200 +#define LUAC_MAXCCALLS 200 -/* maximum size for the virtual stack of a C function */ -#define MAXCSTACK 2048 +/* CONFIG: maximum size for the virtual stack of a C function */ +#define LUAC_MAXCSTACK 2048 /* -** maximum number of syntactical nested non-terminals: Not too big, +** CONFIG: maximum number of syntactical nested non-terminals: Not too big, ** or may overflow the C stack... */ -#define LUA_MAXPARSERLEVEL 200 +#define LUAC_MAXPARSERLEVEL 200 -/* maximum number of variables declared in a function */ -#define MAXVARS 200 /* b, 1) -#define L_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } -#define l_jmpbuf jmp_buf +#define LUAC_THROW(L,c) longjmp((c)->b, 1) +#define LUAC_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } +#define luac_jmpbuf jmp_buf #else /* C++ exceptions */ -#define L_THROW(L,c) throw(c) -#define L_TRY(L,c,a) try { a } catch(...) \ +#define LUAC_THROW(L,c) throw(c) +#define LUAC_TRY(L,c,a) try { a } catch(...) \ { if ((c)->status == 0) (c)->status = -1; } -#define l_jmpbuf int /* dummy variable */ +#define luac_jmpbuf int /* dummy variable */ #endif /* -** macros for thread synchronization inside Lua core machine: This is -** an attempt to simplify the implementation of a multithreaded version -** of Lua. Do not change that unless you know what you are doing. all -** accesses to the global state and to global objects are synchronized. -** Because threads can read the stack of other threads (when running -** garbage collection), a thread must also synchronize any write-access -** to its own stack. Unsynchronized accesses are allowed only when -** reading its own stack, or when reading immutable fields from global -** objects (such as string values and udata values). +** CONFIG: macros for thread synchronization inside Lua core +** machine: This is an attempt to simplify the implementation of a +** multithreaded version of Lua. Do not change that unless you know +** what you are doing. all accesses to the global state and to global +** objects are synchronized. Because threads can read the stack of +** other threads (when running garbage collection), a thread must also +** synchronize any write-access to its own stack. Unsynchronized +** accesses are allowed only when reading its own stack, or when reading +** immutable fields from global objects (such as string values and udata +** values). */ #define lua_lock(L) ((void) 0) #define lua_unlock(L) ((void) 0) /* -** this macro allows a thread switch in appropriate places in the Lua -** core +** CONFIG: this macro allows a thread switch in appropriate places in +** the Lua core */ #define lua_threadyield(L) {lua_unlock(L); lua_lock(L);} -/* allows user-specific initialization on new threads */ +/* CONFIG: allows user-specific initialization on new threads */ #define lua_userstateopen(L) ((void)0) -#endif - -/* }====================================================== */ -/* -** {====================================================== -** Library configuration -** ======================================================= -*/ - -#ifdef LUA_LIB - - -/* environment variables that hold the search path for packages */ -#define LUA_PATH "LUA_PATH" -#define LUA_CPATH "LUA_CPATH" - -/* prefix for open functions in C libraries */ -#define LUA_POF "luaopen_" - -/* separator for open functions in C libraries */ -#define LUA_OFSEP "_" - -/* directory separator (for submodules) */ -#if defined(_WIN32) -#define LUA_DIRSEP "\\" -#else -#define LUA_DIRSEP "/" -#endif - -/* separator of templates in a path */ -#define LUA_PATHSEP ';' - -/* wild char in each template */ -#define LUA_PATH_MARK "?" - - -/* maximum number of captures in pattern-matching (arbitrary limit) */ -#define MAX_CAPTURES 32 +/* CONFIG: maximum number of captures in pattern-matching (arbitrary limit) */ +#define LUA_MAXCAPTURES 32 /* -** by default, gcc does not get `os.tmpname', because it generates a warning -** when using `tmpname'. Change that if you really want (or do not want) -** `os.tmpname' available. +** CONFIG: by default, gcc does not get `os.tmpname', because it +** generates a warning when using `tmpname'. Change that if you really +** want (or do not want) `os.tmpname' available. */ #ifdef __GNUC__ -#define USE_TMPNAME 0 +#define LUA_USETMPNAME 0 #else -#define USE_TMPNAME 1 +#define LUA_USETMPNAME 1 #endif /* -** Configuration for loadlib: Lua tries to guess the dynamic-library -** system that your platform uses (either Windows' DLL, Mac's dyld, or -** dlopen). If your system is some kind of Unix, there is a good chance -** that USE_DLOPEN will work for it. You may need to adapt also the -** makefile. +** CONFIG: Configuration for loadlib: Lua tries to guess the +** dynamic-library system that your platform uses (either Windows' DLL, +** Mac's dyld, or dlopen). If your system is some kind of Unix, there is +** a good chance that LUA_USEDLOPEN will work for it. You may need to adapt +** also the makefile. */ #if defined(_WIN32) -#define USE_DLL +#define LUA_USEDLL #elif defined(__APPLE__) && defined(__MACH__) -#define USE_DYLD +#define LUA_USEDYLD #elif defined(__linux) || defined(sun) || defined(sgi) || defined(BSD) -#define USE_DLOPEN +#define LUA_USEDLOPEN #endif -#endif - -/* }====================================================== */ - - +/* ======================================================= */ /* Local configuration */ -#undef USE_TMPNAME -#define USE_TMPNAME 1 +#undef LUA_USETMPNAME +#define LUA_USETMPNAME 1 #endif diff --git a/lvm.c b/lvm.c index d2f91ff2..9f647484 100644 --- a/lvm.c +++ b/lvm.c @@ -1,5 +1,5 @@ /* -** $Id: lvm.c,v 2.29 2005/03/08 18:00:16 roberto Exp roberto $ +** $Id: lvm.c,v 2.30 2005/03/08 18:09:16 roberto Exp roberto $ ** Lua virtual machine ** See Copyright Notice in lua.h */ @@ -49,7 +49,7 @@ int luaV_tostring (lua_State *L, StkId obj) { if (!ttisnumber(obj)) return 0; else { - char s[MAX_NUMBER2STR]; + char s[LUAC_MAXNUMBER2STR]; lua_number2str(s, nvalue(obj)); setsvalue2s(L, obj, luaS_new(L, s)); return 1; @@ -243,7 +243,7 @@ int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { if (ttype(l) != ttype(r)) return luaG_ordererror(L, l, r); else if (ttisnumber(l)) - return num_lt(nvalue(l), nvalue(r)); + return luac_numlt(nvalue(l), nvalue(r)); else if (ttisstring(l)) return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0; else if ((res = call_orderTM(L, l, r, TM_LT)) != -1) @@ -257,7 +257,7 @@ static int lessequal (lua_State *L, const TValue *l, const TValue *r) { if (ttype(l) != ttype(r)) return luaG_ordererror(L, l, r); else if (ttisnumber(l)) - return num_le(nvalue(l), nvalue(r)); + return luac_numle(nvalue(l), nvalue(r)); else if (ttisstring(l)) return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0; else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */ @@ -273,7 +273,7 @@ int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) { lua_assert(ttype(t1) == ttype(t2)); switch (ttype(t1)) { case LUA_TNIL: return 1; - case LUA_TNUMBER: return num_eq(nvalue(t1), nvalue(t2)); + case LUA_TNUMBER: return luac_numeq(nvalue(t1), nvalue(t2)); case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); case LUA_TUSERDATA: { @@ -338,12 +338,12 @@ static StkId Arith (lua_State *L, StkId ra, const TValue *rb, (c = luaV_tonumber(rc, &tempc)) != NULL) { lua_Number nb = nvalue(b), nc = nvalue(c); switch (op) { - case TM_ADD: setnvalue(ra, num_add(nb, nc)); break; - case TM_SUB: setnvalue(ra, num_sub(nb, nc)); break; - case TM_MUL: setnvalue(ra, num_mul(nb, nc)); break; - case TM_DIV: setnvalue(ra, num_div(nb, nc)); break; - case TM_MOD: setnvalue(ra, num_mod(nb, nc)); break; - case TM_POW: setnvalue(ra, num_pow(nb, nc)); break; + case TM_ADD: setnvalue(ra, luac_numadd(nb, nc)); break; + case TM_SUB: setnvalue(ra, luac_numsub(nb, nc)); break; + case TM_MUL: setnvalue(ra, luac_nummul(nb, nc)); break; + case TM_DIV: setnvalue(ra, luac_numdiv(nb, nc)); break; + case TM_MOD: setnvalue(ra, luac_nummod(nb, nc)); break; + case TM_POW: setnvalue(ra, luac_numpow(nb, nc)); break; default: lua_assert(0); break; } } @@ -480,7 +480,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_add(nb, nc)); + setnvalue(ra, luac_numadd(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_ADD, pc); /***/ @@ -491,7 +491,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_sub(nb, nc)); + setnvalue(ra, luac_numsub(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_SUB, pc); /***/ @@ -502,7 +502,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_mul(nb, nc)); + setnvalue(ra, luac_nummul(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_MUL, pc); /***/ @@ -513,7 +513,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_div(nb, nc)); + setnvalue(ra, luac_numdiv(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_DIV, pc); /***/ @@ -524,7 +524,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_mod(nb, nc)); + setnvalue(ra, luac_nummod(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_MOD, pc); /***/ @@ -535,7 +535,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); - setnvalue(ra, num_pow(nb, nc)); + setnvalue(ra, luac_numpow(nb, nc)); } else base = Arith(L, ra, rb, rc, TM_POW, pc); /***/ @@ -546,7 +546,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { TValue temp; if (tonumber(rb, &temp)) { lua_Number nb = nvalue(rb); - setnvalue(ra, num_unm(nb)); + setnvalue(ra, luac_numunm(nb)); } else { setnilvalue(&temp); @@ -682,9 +682,9 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { } case OP_FORLOOP: { lua_Number step = nvalue(ra+2); - lua_Number idx = num_add(nvalue(ra), step); /* increment index */ + lua_Number idx = luac_numadd(nvalue(ra), step); /* increment index */ lua_Number limit = nvalue(ra+1); - if (step > 0 ? num_le(idx, limit) : num_le(limit, idx)) { + if (step > 0 ? luac_numle(idx, limit) : luac_numle(limit, idx)) { dojump(L, pc, GETARG_sBx(i)); /* jump back */ setnvalue(ra, idx); /* update internal index... */ setnvalue(ra+3, idx); /* ...and external index */ @@ -702,7 +702,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) { luaG_runerror(L, "`for' limit must be a number"); else if (!tonumber(pstep, ra+2)) luaG_runerror(L, "`for' step must be a number"); - setnvalue(ra, num_sub(nvalue(ra), nvalue(pstep))); + setnvalue(ra, luac_numsub(nvalue(ra), nvalue(pstep))); dojump(L, pc, GETARG_sBx(i)); continue; }