rusefi
/
lua
mirror of https://github.com/rusefi/lua.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

`luaconf.h´ exports all its definitions always (so all of them 

must have a lua/LUA prefix).
This commit is contained in:
Roberto Ierusalimschy 2005-03-08 17:10:05 -03:00
parent d3902cfa81
commit f8df21bd20
16 changed files with 237 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lapi.c
View File

@ -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 ** Lua API
** See Copyright Notice in lua.h ** 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) { LUA_API int lua_checkstack (lua_State *L, int size) {
int res; int res;
lua_lock(L); lua_lock(L);
if ((L->top - L->base + size) > MAXCSTACK) if ((L->top - L->base + size) > LUAC_MAXCSTACK)
res = 0; /* stack overflow */ res = 0; /* stack overflow */
else { else {
luaD_checkstack(L, size); luaD_checkstack(L, size);

4
lcode.c
View File

@ -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 ** Code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -606,7 +606,7 @@ void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
if (op == OPR_MINUS) { if (op == OPR_MINUS) {
luaK_exp2val(fs, e); luaK_exp2val(fs, e);
if (e->k == VK && ttisnumber(&fs->f->k[e->info])) 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 { else {
luaK_exp2anyreg(fs, e); luaK_exp2anyreg(fs, e);
freeexp(fs, e); freeexp(fs, e);

54
ldblib.c
View File

@ -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 ** Interface from Lua to its debug API
** See Copyright Notice in lua.h ** 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); luaL_checkany(L, 1);
if (!lua_getmetatable(L, 1)) { if (!lua_getmetatable(L, 1)) {
lua_pushnil(L); /* no metatable */ 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); int t = lua_type(L, 2);
luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
"nil or table expected"); "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); lua_getfenv(L, 1);
return 1; return 1;
} }
static int setfenv (lua_State *L) { static int db_setfenv (lua_State *L) {
luaL_checktype(L, 2, LUA_TTABLE); luaL_checktype(L, 2, LUA_TTABLE);
lua_settop(L, 2); lua_settop(L, 2);
if (lua_setfenv(L, 1) == 0) 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; lua_Debug ar;
int arg; int arg;
lua_State *L1 = getthread(L, &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; int arg;
lua_State *L1 = getthread(L, &arg); lua_State *L1 = getthread(L, &arg);
lua_Debug ar; 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; int arg;
lua_State *L1 = getthread(L, &arg); lua_State *L1 = getthread(L, &arg);
lua_Debug ar; 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); return auxupvalue(L, 1);
} }
static int setupvalue (lua_State *L) { static int db_setupvalue (lua_State *L) {
luaL_checkany(L, 3); luaL_checkany(L, 3);
return auxupvalue(L, 0); 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; int arg;
lua_State *L1 = getthread(L, &arg); lua_State *L1 = getthread(L, &arg);
if (lua_isnoneornil(L, arg+1)) { 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; int arg;
lua_State *L1 = getthread(L, &arg); lua_State *L1 = getthread(L, &arg);
char buff[5]; 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 (;;) { for (;;) {
char buffer[250]; char buffer[250];
fputs("lua_debug> ", stderr); 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 LEVELS1 12 /* size of the first part of the stack */
#define LEVELS2 10 /* size of the second 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 level;
int firstpart = 1; /* still before eventual `...' */ int firstpart = 1; /* still before eventual `...' */
int arg; int arg;
@ -362,19 +362,19 @@ static int errorfb (lua_State *L) {
static const luaL_reg dblib[] = { static const luaL_reg dblib[] = {
{"getmetatable", getmetatable}, {"getmetatable", db_getmetatable},
{"setmetatable", setmetatable}, {"setmetatable", db_setmetatable},
{"getfenv", getfenv}, {"getfenv", db_getfenv},
{"setfenv", setfenv}, {"setfenv", db_setfenv},
{"getlocal", getlocal}, {"getlocal", db_getlocal},
{"getinfo", getinfo}, {"getinfo", db_getinfo},
{"gethook", gethook}, {"gethook", db_gethook},
{"getupvalue", getupvalue}, {"getupvalue", db_getupvalue},
{"sethook", sethook}, {"sethook", db_sethook},
{"setlocal", setlocal}, {"setlocal", db_setlocal},
{"setupvalue", setupvalue}, {"setupvalue", db_setupvalue},
{"debug", debug}, {"debug", db_debug},
{"traceback", errorfb}, {"traceback", db_errorfb},
{NULL, NULL} {NULL, NULL}
}; };

24
ldo.c
View File

@ -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 ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -43,7 +43,7 @@
/* chain list of long jump buffers */ /* chain list of long jump buffers */
struct lua_longjmp { struct lua_longjmp {
struct lua_longjmp *previous; struct lua_longjmp *previous;
l_jmpbuf b; luac_jmpbuf b;
volatile int status; /* error code */ 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) { void luaD_throw (lua_State *L, int errcode) {
if (L->errorJmp) { if (L->errorJmp) {
L->errorJmp->status = errcode; L->errorJmp->status = errcode;
L_THROW(L, L->errorJmp); LUAC_THROW(L, L->errorJmp);
} }
else { else {
if (G(L)->panic) G(L)->panic(L); 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.status = 0;
lj.previous = L->errorJmp; /* chain new error handler */ lj.previous = L->errorJmp; /* chain new error handler */
L->errorJmp = &lj; L->errorJmp = &lj;
L_TRY(L, &lj, LUAC_TRY(L, &lj,
(*f)(L, ud); (*f)(L, ud);
); );
L->errorJmp = lj.previous; /* restore old error handler */ 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) { static void restore_stack_limit (lua_State *L) {
lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1); 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); int inuse = (L->ci - L->base_ci);
if (inuse + 1 < LUA_MAXCALLS) /* can `undo' overflow? */ if (inuse + 1 < LUAC_MAXCALLS) /* can `undo' overflow? */
luaD_reallocCI(L, LUA_MAXCALLS); luaD_reallocCI(L, LUAC_MAXCALLS);
} }
} }
@ -149,11 +149,11 @@ void luaD_growstack (lua_State *L, int n) {
static CallInfo *growCI (lua_State *L) { 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); luaD_throw(L, LUA_ERRERR);
else { else {
luaD_reallocCI(L, 2*L->size_ci); luaD_reallocCI(L, 2*L->size_ci);
if (L->size_ci > LUA_MAXCALLS) if (L->size_ci > LUAC_MAXCALLS)
luaG_runerror(L, "stack overflow"); luaG_runerror(L, "stack overflow");
} }
return ++L->ci; return ++L->ci;
@ -340,10 +340,10 @@ void luaD_poscall (lua_State *L, int wanted, StkId firstResult) {
** function position. ** function position.
*/ */
void luaD_call (lua_State *L, StkId func, int nResults) { void luaD_call (lua_State *L, StkId func, int nResults) {
if (++L->nCcalls >= LUA_MAXCCALLS) { if (++L->nCcalls >= LUAC_MAXCCALLS) {
if (L->nCcalls == LUA_MAXCCALLS) if (L->nCcalls == LUAC_MAXCCALLS)
luaG_runerror(L, "C stack overflow"); 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 */ luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
} }
if (luaD_precall(L, func, nResults) == PCRLUA) { /* is a Lua function? */ if (luaD_precall(L, func, nResults) == PCRLUA) { /* is a Lua function? */

4
lgc.c
View File

@ -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 ** Garbage Collector
** See Copyright Notice in lua.h ** 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) { static void checkstacksizes (lua_State *L, StkId max) {
int ci_used = L->ci - L->base_ci; /* number of `ci' in use */ int ci_used = L->ci - L->base_ci; /* number of `ci' in use */
int s_used = max - L->stack; /* part of stack 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 */ return; /* do not touch the stacks */
if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci) if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
luaD_reallocCI(L, L->size_ci/2); /* still big enough... */ luaD_reallocCI(L, L->size_ci/2); /* still big enough... */

14
llimits.h
View File

@ -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 ** Limits, basic types, and some other `installation-dependent' definitions
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -15,12 +15,14 @@
#include "lua.h" #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 */ /* 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 */ /* 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)) #define check_exp(c,e) (lua_assert(c), (e))

9
loadlib.c
View File

@ -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 ** Dynamic library loader for Lua
** See Copyright Notice in lua.h ** 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. ** 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. ** 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 ** Native Mac OS X / Darwin Implementation
@ -119,6 +119,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
#include <mach-o/dyld.h> #include <mach-o/dyld.h>
/* Mac appends a `_' before C function names */
#undef POF #undef POF
#define POF "_" LUA_POF #define POF "_" LUA_POF

4
lobject.c
View File

@ -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 ** Some generic functions over Lua objects
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -74,7 +74,7 @@ int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
case LUA_TNIL: case LUA_TNIL:
return 1; return 1;
case LUA_TNUMBER: case LUA_TNUMBER:
return num_eq(nvalue(t1), nvalue(t2)); return luac_numeq(nvalue(t1), nvalue(t2));
case LUA_TBOOLEAN: case LUA_TBOOLEAN:
return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */ return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */
case LUA_TLIGHTUSERDATA: case LUA_TLIGHTUSERDATA:

6
lopcodes.h
View File

@ -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 ** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -51,9 +51,9 @@ enum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */
/* /*
** limits for opcode arguments. ** limits for opcode arguments.
** we use (signed) int to manipulate most 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<<SIZE_Bx)-1) #define MAXARG_Bx ((1<<SIZE_Bx)-1)
#define MAXARG_sBx (MAXARG_Bx>>1) /* `sBx' is signed */ #define MAXARG_sBx (MAXARG_Bx>>1) /* `sBx' is signed */
#else #else

4
loslib.c
View File

@ -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 ** Standard Operating System library
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -57,7 +57,7 @@ static int io_rename (lua_State *L) {
static int io_tmpname (lua_State *L) { static int io_tmpname (lua_State *L) {
#if !USE_TMPNAME #if !LUA_USETMPNAME
luaL_error(L, "`tmpname' not supported"); luaL_error(L, "`tmpname' not supported");
return 0; return 0;
#else #else

12
lparser.c
View File

@ -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 ** Lua Parser
** See Copyright Notice in lua.h ** 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 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) luaX_lexerror(ls, "chunk has too many syntax levels", 0)
#define leavelevel(ls) ((ls)->nestlevel--) #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) { static void new_localvar (LexState *ls, TString *name, int n) {
FuncState *fs = ls->fs; 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)); 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 */ /* 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, luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
TString *, MAX_INT, ""); TString *, MAX_INT, "");
while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL; while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
@ -993,7 +993,7 @@ static int cond (LexState *ls) {
static void whilestat (LexState *ls, int line) { static void whilestat (LexState *ls, int line) {
/* whilestat -> WHILE cond DO block END */ /* whilestat -> WHILE cond DO block END */
Instruction codeexp[MAXEXPWHILE + EXTRAEXP]; Instruction codeexp[LUAC_MAXEXPWHILE + EXTRAEXP];
int lineexp; int lineexp;
int i; int i;
int sizeexp; int sizeexp;
@ -1011,7 +1011,7 @@ static void whilestat (LexState *ls, int line) {
luaK_concat(fs, &v.f, fs->jpc); luaK_concat(fs, &v.f, fs->jpc);
fs->jpc = NO_JUMP; fs->jpc = NO_JUMP;
sizeexp = fs->pc - expinit; /* size of expression code */ sizeexp = fs->pc - expinit; /* size of expression code */
if (sizeexp > MAXEXPWHILE) if (sizeexp > LUAC_MAXEXPWHILE)
luaX_syntaxerror(ls, "`while' condition too complex"); luaX_syntaxerror(ls, "`while' condition too complex");
for (i = 0; i < sizeexp; i++) /* save `exp' code */ for (i = 0; i < sizeexp; i++) /* save `exp' code */
codeexp[i] = fs->f->code[expinit + i]; codeexp[i] = fs->f->code[expinit + i];

6
lparser.h
View File

@ -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 ** Lua Parser
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -67,8 +67,8 @@ typedef struct FuncState {
int np; /* number of elements in `p' */ int np; /* number of elements in `p' */
short nlocvars; /* number of elements in `locvars' */ short nlocvars; /* number of elements in `locvars' */
lu_byte nactvar; /* number of active local variables */ lu_byte nactvar; /* number of active local variables */
upvaldesc upvalues[MAXUPVALUES]; /* upvalues */ upvaldesc upvalues[LUAC_MAXUPVALUES]; /* upvalues */
unsigned short actvar[MAXVARS]; /* declared-variable stack */ unsigned short actvar[LUAC_MAXVARS]; /* declared-variable stack */
} FuncState; } FuncState;

6
lstrlib.c
View File

@ -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 ** Standard library for string operations and pattern-matching
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -172,7 +172,7 @@ typedef struct MatchState {
struct { struct {
const char *init; const char *init;
ptrdiff_t len; ptrdiff_t len;
} capture[MAX_CAPTURES]; } capture[LUA_MAXCAPTURES];
} MatchState; } MatchState;
@ -327,7 +327,7 @@ static const char *start_capture (MatchState *ms, const char *s,
const char *p, int what) { const char *p, int what) {
const char *res; const char *res;
int level = ms->level; 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].init = s;
ms->capture[level].len = what; ms->capture[level].len = what;
ms->level = level+1; ms->level = level+1;

14
ltable.c
View File

@ -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) ** Lua tables (hash)
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -38,10 +38,10 @@
/* /*
** max size of array part is 2^MAXBITS ** max size of array part is 2^MAXBITS
*/ */
#if LUA_BITSINT > 26 #if LUAC_BITSINT > 26
#define MAXBITS 26 #define MAXBITS 26
#else #else
#define MAXBITS (LUA_BITSINT-2) #define MAXBITS (LUAC_BITSINT-2)
#endif #endif
#define MAXASIZE (1 << MAXBITS) #define MAXASIZE (1 << MAXBITS)
@ -120,7 +120,7 @@ static int arrayindex (const TValue *key) {
lua_Number n = nvalue(key); lua_Number n = nvalue(key);
int k; int k;
lua_number2int(k, n); 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 k;
} }
return -1; /* `key' did not match some condition */ 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); lua_Number nk = cast(lua_Number, key);
Node *n = hashnum(t, nk); Node *n = hashnum(t, nk);
do { /* check whether `key' is somewhere in the chain */ 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 */ return gval(n); /* that's it */
else n = gnext(n); else n = gnext(n);
} while (n); } while (n);
@ -470,7 +470,7 @@ const TValue *luaH_get (Table *t, const TValue *key) {
case LUA_TNUMBER: { case LUA_TNUMBER: {
int k; int k;
lua_number2int(k, (nvalue(key))); 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 */ return luaH_getnum(t, k); /* use specialized version */
/* else go through */ /* else go through */
} }
@ -494,7 +494,7 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
return cast(TValue *, p); return cast(TValue *, p);
else { else {
if (ttisnil(key)) luaG_runerror(L, "table index is nil"); 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"); luaG_runerror(L, "table index is NaN");
return newkey(L, t, key); return newkey(L, t, key);
} }

283
luaconf.h
View File

@ -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 ** Configuration file for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -30,7 +30,7 @@
** ======================================================= ** =======================================================
*/ */
/* default path */ /* CONFIG: default path */
#if defined(_WIN32) #if defined(_WIN32)
#define LUA_ROOT "C:\\Program Files\\Lua51" #define LUA_ROOT "C:\\Program Files\\Lua51"
#define LUA_LDIR LUA_ROOT "\\lua" #define LUA_LDIR LUA_ROOT "\\lua"
@ -51,33 +51,58 @@
#endif #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 #define LUA_NUMBER double
/* formats for Lua numbers */ /* CONFIG: formats for Lua numbers */
#define LUA_NUMBER_SCAN "%lf" #define LUA_NUMBER_SCAN "%lf"
#define LUA_NUMBER_FMT "%.14g" #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 ** on most machines, `ptrdiff_t' gives a reasonable size for integers
*/ */
#define LUA_INTEGER ptrdiff_t #define LUA_INTEGER ptrdiff_t
/* mark for all API functions */ /* CONFIG: mark for all API functions */
#define LUA_API extern #define LUA_API extern
/* mark for auxlib functions */ /* CONFIG: mark for auxlib functions */
#define LUALIB_API extern #define LUALIB_API extern
/* buffer size used by lauxlib buffer system */ /* CONFIG: buffer size used by lauxlib buffer system */
#define LUAL_BUFFERSIZE BUFSIZ #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) #define lua_assert(c) ((void)0)
/* }====================================================== */ /* }====================================================== */
@ -92,7 +117,7 @@
#ifdef lua_c #ifdef lua_c
/* definition of `isatty' */ /* CONFIG: definition of `isatty' */
#ifdef _POSIX_C_SOURCE #ifdef _POSIX_C_SOURCE
#include <unistd.h> #include <unistd.h>
#define stdin_is_tty() isatty(0) #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 ** read in manual input
*/ */
#define lua_saveline(L,line) /* empty */ #define lua_saveline(L,line) /* empty */
@ -126,86 +151,80 @@
/* /* CONFIG: LUA-C API assertions */
** {====================================================== #define luac_apicheck(L,o) lua_assert(o)
** Core configuration
** =======================================================
*/
#ifdef LUA_CORE
/* LUA-C API assertions */
#define api_check(L,o) lua_assert(o)
/* number of bits in an `int' */ /* number of bits in an `int' */
/* avoid overflows in comparison */ /* avoid overflows in comparison */
#if INT_MAX-20 < 32760 #if INT_MAX-20 < 32760
#define LUA_BITSINT 16 #define LUAC_BITSINT 16
#elif INT_MAX > 2147483640L #elif INT_MAX > 2147483640L
/* `int' has at least 32 bits */ /* `int' has at least 32 bits */
#define LUA_BITSINT 32 #define LUAC_BITSINT 32
#else #else
#error "you must define LUA_BITSINT with number of bits in an integer" #error "you must define LUA_BITSINT with number of bits in an integer"
#endif #endif
/* /*
** L_UINT32: unsigned integer with at least 32 bits ** CONFIG:
** L_INT32: signed integer with at least 32 bits ** LUAC_UINT32: unsigned integer with at least 32 bits
** LU_MEM: an unsigned integer big enough to count the total memory used by Lua ** LUAC_INT32: signed integer with at least 32 bits
** L_MEM: a signed integer big enough to count the total memory used by Lua ** 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 #if LUAC_BITSINT >= 32
#define LUA_UINT32 unsigned int #define LUAC_UINT32 unsigned int
#define LUA_INT32 int #define LUAC_INT32 int
#define LUA_MAXINT32 INT_MAX #define LUAC_MAXINT32 INT_MAX
#define LU_MEM size_t #define LUAC_UMEM size_t
#define L_MEM ptrdiff_t #define LUAC_MEM ptrdiff_t
#else #else
/* 16-bit ints */ /* 16-bit ints */
#define LUA_UINT32 unsigned long #define LUAC_UINT32 unsigned long
#define LUA_INT32 long #define LUAC_INT32 long
#define LUA_MAXINT32 LONG_MAX #define LUAC_MAXINT32 LONG_MAX
#define LU_MEM LUA_UINT32 #define LUAC_UMEM LUAC_UINT32
#define L_MEM ptrdiff_t #define LUAC_MEM ptrdiff_t
#endif #endif
/* maximum depth for calls (unsigned short) */ /* CONFIG: maximum depth for calls (unsigned short) */
#define LUA_MAXCALLS 10000 #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... ** overflow the C stack...
*/ */
#define LUA_MAXCCALLS 200 #define LUAC_MAXCCALLS 200
/* maximum size for the virtual stack of a C function */ /* CONFIG: maximum size for the virtual stack of a C function */
#define MAXCSTACK 2048 #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... ** or may overflow the C stack...
*/ */
#define LUA_MAXPARSERLEVEL 200 #define LUAC_MAXPARSERLEVEL 200
/* maximum number of variables declared in a function */ /* CONFIG: maximum number of variables declared in a function */
#define MAXVARS 200 /* <MAXSTACK */ #define LUAC_MAXVARS 200 /* <MAXSTACK */
/* maximum number of upvalues per function */ /* CONFIG: maximum number of upvalues per function */
#define MAXUPVALUES 60 /* <MAXSTACK */ #define LUAC_MAXUPVALUES 60 /* <MAXSTACK */
/* maximum size of expressions for optimizing `while' code */ /* CONFIG: maximum size of expressions for optimizing `while' code */
#define MAXEXPWHILE 100 #define LUAC_MAXEXPWHILE 100
/* function to convert a lua_Number to int (with any rounding method) */ /* CONFIG: function to convert a lua_Number to int (with any rounding method) */
#if defined(__GNUC__) && defined(__i386) #if defined(__GNUC__) && defined(__i386)
#define lua_number2int(i,d) __asm__ ("fistpl %0":"=m"(i):"t"(d):"st") #define lua_number2int(i,d) __asm__ ("fistpl %0":"=m"(i):"t"(d):"st")
@ -231,171 +250,133 @@ __inline int l_lrint (double flt)
#endif #endif
/* function to convert a lua_Number to lua_Integer (with any rounding method) */ /* CONFIG: function to convert a lua_Number to lua_Integer (with any rounding method) */
#define lua_number2integer(i,n) lua_number2int((i), (n)) #define lua_number2integer(i,n) lua_number2int((i), (n))
/* function to convert a lua_Number to a string */ /* CONFIG: function to convert a lua_Number to a string */
#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
/* maximum size of previous conversion */ /* maximum size of previous conversion */
#define MAX_NUMBER2STR 32 /* 16 digits, sign, point and \0 (+ some extra) */ #define LUAC_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
/* function to convert a string to a lua_Number */ /* CONFIG: function to convert a string to a lua_Number */
#define lua_str2number(s,p) strtod((s), (p)) #define lua_str2number(s,p) strtod((s), (p))
/* result of a `usual argument conversion' over lua_Number */ /* CONFIG: result of a `usual argument conversion' over lua_Number */
#define LUA_UACNUMBER double #define LUAC_UACNUMBER double
/* primitive operators for numbers */ /* CONFIG: primitive operators for numbers */
#define num_add(a,b) ((a)+(b)) #define luac_numadd(a,b) ((a)+(b))
#define num_sub(a,b) ((a)-(b)) #define luac_numsub(a,b) ((a)-(b))
#define num_mul(a,b) ((a)*(b)) #define luac_nummul(a,b) ((a)*(b))
#define num_div(a,b) ((a)/(b)) #define luac_numdiv(a,b) ((a)/(b))
#define num_unm(a) (-(a)) #define luac_numunm(a) (-(a))
#define num_eq(a,b) ((a)==(b)) #define luac_numeq(a,b) ((a)==(b))
#define num_lt(a,b) ((a)<(b)) #define luac_numlt(a,b) ((a)<(b))
#define num_le(a,b) ((a)<=(b)) #define luac_numle(a,b) ((a)<=(b))
#define num_mod(a,b) ((a) - floor((a)/(b))*(b)) #define luac_nummod(a,b) ((a) - floor((a)/(b))*(b))
#define num_pow(a,b) pow(a,b) #define luac_numpow(a,b) pow(a,b)
/* type to ensure maximum alignment */ /* CONFIG: type to ensure maximum alignment */
#define LUSER_ALIGNMENT_T union { double u; void *s; long l; } #define LUAC_USER_ALIGNMENT_T union { double u; void *s; long l; }
/* /*
** exception handling: by default, Lua handles errors with longjmp/setjmp ** CONFIG: exception handling: by default, Lua handles errors with
** when compiling as C code and with exceptions when compiling as C++ code. ** longjmp/setjmp when compiling as C code and with exceptions
** Change that if you prefer to use longjmp/setjmp even with C++. ** when compiling as C++ code. Change that if you prefer to use
** longjmp/setjmp even with C++.
*/ */
#ifndef __cplusplus #ifndef __cplusplus
/* default handling with long jumps */ /* default handling with long jumps */
#define L_THROW(L,c) longjmp((c)->b, 1) #define LUAC_THROW(L,c) longjmp((c)->b, 1)
#define L_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } #define LUAC_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
#define l_jmpbuf jmp_buf #define luac_jmpbuf jmp_buf
#else #else
/* C++ exceptions */ /* C++ exceptions */
#define L_THROW(L,c) throw(c) #define LUAC_THROW(L,c) throw(c)
#define L_TRY(L,c,a) try { a } catch(...) \ #define LUAC_TRY(L,c,a) try { a } catch(...) \
{ if ((c)->status == 0) (c)->status = -1; } { if ((c)->status == 0) (c)->status = -1; }
#define l_jmpbuf int /* dummy variable */ #define luac_jmpbuf int /* dummy variable */
#endif #endif
/* /*
** macros for thread synchronization inside Lua core machine: This is ** CONFIG: macros for thread synchronization inside Lua core
** an attempt to simplify the implementation of a multithreaded version ** machine: This is an attempt to simplify the implementation of a
** of Lua. Do not change that unless you know what you are doing. all ** multithreaded version of Lua. Do not change that unless you know
** accesses to the global state and to global objects are synchronized. ** what you are doing. all accesses to the global state and to global
** Because threads can read the stack of other threads (when running ** objects are synchronized. Because threads can read the stack of
** garbage collection), a thread must also synchronize any write-access ** other threads (when running garbage collection), a thread must also
** to its own stack. Unsynchronized accesses are allowed only when ** synchronize any write-access to its own stack. Unsynchronized
** reading its own stack, or when reading immutable fields from global ** accesses are allowed only when reading its own stack, or when reading
** objects (such as string values and udata values). ** immutable fields from global objects (such as string values and udata
** values).
*/ */
#define lua_lock(L) ((void) 0) #define lua_lock(L) ((void) 0)
#define lua_unlock(L) ((void) 0) #define lua_unlock(L) ((void) 0)
/* /*
** this macro allows a thread switch in appropriate places in the Lua ** CONFIG: this macro allows a thread switch in appropriate places in
** core ** the Lua core
*/ */
#define lua_threadyield(L) {lua_unlock(L); lua_lock(L);} #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) #define lua_userstateopen(L) ((void)0)
#endif
/* }====================================================== */
/* /* CONFIG: maximum number of captures in pattern-matching (arbitrary limit) */
** {====================================================== #define LUA_MAXCAPTURES 32
** 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
/* /*
** by default, gcc does not get `os.tmpname', because it generates a warning ** CONFIG: by default, gcc does not get `os.tmpname', because it
** when using `tmpname'. Change that if you really want (or do not want) ** generates a warning when using `tmpname'. Change that if you really
** `os.tmpname' available. ** want (or do not want) `os.tmpname' available.
*/ */
#ifdef __GNUC__ #ifdef __GNUC__
#define USE_TMPNAME 0 #define LUA_USETMPNAME 0
#else #else
#define USE_TMPNAME 1 #define LUA_USETMPNAME 1
#endif #endif
/* /*
** Configuration for loadlib: Lua tries to guess the dynamic-library ** CONFIG: Configuration for loadlib: Lua tries to guess the
** system that your platform uses (either Windows' DLL, Mac's dyld, or ** dynamic-library system that your platform uses (either Windows' DLL,
** dlopen). If your system is some kind of Unix, there is a good chance ** Mac's dyld, or dlopen). If your system is some kind of Unix, there is
** that USE_DLOPEN will work for it. You may need to adapt also the ** a good chance that LUA_USEDLOPEN will work for it. You may need to adapt
** makefile. ** also the makefile.
*/ */
#if defined(_WIN32) #if defined(_WIN32)
#define USE_DLL #define LUA_USEDLL
#elif defined(__APPLE__) && defined(__MACH__) #elif defined(__APPLE__) && defined(__MACH__)
#define USE_DYLD #define LUA_USEDYLD
#elif defined(__linux) || defined(sun) || defined(sgi) || defined(BSD) #elif defined(__linux) || defined(sun) || defined(sgi) || defined(BSD)
#define USE_DLOPEN #define LUA_USEDLOPEN
#endif #endif
#endif
/* }====================================================== */
/* ======================================================= */
/* Local configuration */ /* Local configuration */
#undef USE_TMPNAME #undef LUA_USETMPNAME
#define USE_TMPNAME 1 #define LUA_USETMPNAME 1
#endif #endif

42
lvm.c
View File

@ -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 ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -49,7 +49,7 @@ int luaV_tostring (lua_State *L, StkId obj) {
if (!ttisnumber(obj)) if (!ttisnumber(obj))
return 0; return 0;
else { else {
char s[MAX_NUMBER2STR]; char s[LUAC_MAXNUMBER2STR];
lua_number2str(s, nvalue(obj)); lua_number2str(s, nvalue(obj));
setsvalue2s(L, obj, luaS_new(L, s)); setsvalue2s(L, obj, luaS_new(L, s));
return 1; return 1;
@ -243,7 +243,7 @@ int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
if (ttype(l) != ttype(r)) if (ttype(l) != ttype(r))
return luaG_ordererror(L, l, r); return luaG_ordererror(L, l, r);
else if (ttisnumber(l)) else if (ttisnumber(l))
return num_lt(nvalue(l), nvalue(r)); return luac_numlt(nvalue(l), nvalue(r));
else if (ttisstring(l)) else if (ttisstring(l))
return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0; return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
else if ((res = call_orderTM(L, l, r, TM_LT)) != -1) 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)) if (ttype(l) != ttype(r))
return luaG_ordererror(L, l, r); return luaG_ordererror(L, l, r);
else if (ttisnumber(l)) else if (ttisnumber(l))
return num_le(nvalue(l), nvalue(r)); return luac_numle(nvalue(l), nvalue(r));
else if (ttisstring(l)) else if (ttisstring(l))
return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0; return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */ 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)); lua_assert(ttype(t1) == ttype(t2));
switch (ttype(t1)) { switch (ttype(t1)) {
case LUA_TNIL: return 1; 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_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
case LUA_TUSERDATA: { case LUA_TUSERDATA: {
@ -338,12 +338,12 @@ static StkId Arith (lua_State *L, StkId ra, const TValue *rb,
(c = luaV_tonumber(rc, &tempc)) != NULL) { (c = luaV_tonumber(rc, &tempc)) != NULL) {
lua_Number nb = nvalue(b), nc = nvalue(c); lua_Number nb = nvalue(b), nc = nvalue(c);
switch (op) { switch (op) {
case TM_ADD: setnvalue(ra, num_add(nb, nc)); break; case TM_ADD: setnvalue(ra, luac_numadd(nb, nc)); break;
case TM_SUB: setnvalue(ra, num_sub(nb, nc)); break; case TM_SUB: setnvalue(ra, luac_numsub(nb, nc)); break;
case TM_MUL: setnvalue(ra, num_mul(nb, nc)); break; case TM_MUL: setnvalue(ra, luac_nummul(nb, nc)); break;
case TM_DIV: setnvalue(ra, num_div(nb, nc)); break; case TM_DIV: setnvalue(ra, luac_numdiv(nb, nc)); break;
case TM_MOD: setnvalue(ra, num_mod(nb, nc)); break; case TM_MOD: setnvalue(ra, luac_nummod(nb, nc)); break;
case TM_POW: setnvalue(ra, num_pow(nb, nc)); break; case TM_POW: setnvalue(ra, luac_numpow(nb, nc)); break;
default: lua_assert(0); break; default: lua_assert(0); break;
} }
} }
@ -480,7 +480,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) {
TValue *rc = RKC(i); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_add(nb, nc)); setnvalue(ra, luac_numadd(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_ADD, pc); /***/ 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); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_sub(nb, nc)); setnvalue(ra, luac_numsub(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_SUB, pc); /***/ 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); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_mul(nb, nc)); setnvalue(ra, luac_nummul(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_MUL, pc); /***/ 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); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_div(nb, nc)); setnvalue(ra, luac_numdiv(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_DIV, pc); /***/ 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); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_mod(nb, nc)); setnvalue(ra, luac_nummod(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_MOD, pc); /***/ 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); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
lua_Number nb = nvalue(rb), nc = nvalue(rc); lua_Number nb = nvalue(rb), nc = nvalue(rc);
setnvalue(ra, num_pow(nb, nc)); setnvalue(ra, luac_numpow(nb, nc));
} }
else else
base = Arith(L, ra, rb, rc, TM_POW, pc); /***/ base = Arith(L, ra, rb, rc, TM_POW, pc); /***/
@ -546,7 +546,7 @@ StkId luaV_execute (lua_State *L, int nexeccalls) {
TValue temp; TValue temp;
if (tonumber(rb, &temp)) { if (tonumber(rb, &temp)) {
lua_Number nb = nvalue(rb); lua_Number nb = nvalue(rb);
setnvalue(ra, num_unm(nb)); setnvalue(ra, luac_numunm(nb));
} }
else { else {
setnilvalue(&temp); setnilvalue(&temp);
@ -682,9 +682,9 @@ StkId luaV_execute (lua_State *L, int nexeccalls) {
} }
case OP_FORLOOP: { case OP_FORLOOP: {
lua_Number step = nvalue(ra+2); 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); 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 */ dojump(L, pc, GETARG_sBx(i)); /* jump back */
setnvalue(ra, idx); /* update internal index... */ setnvalue(ra, idx); /* update internal index... */
setnvalue(ra+3, idx); /* ...and external 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"); luaG_runerror(L, "`for' limit must be a number");
else if (!tonumber(pstep, ra+2)) else if (!tonumber(pstep, ra+2))
luaG_runerror(L, "`for' step must be a number"); 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)); dojump(L, pc, GETARG_sBx(i));
continue; continue;
} }