github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-07-16 10:03:04 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

liblua: fix mix of spaces & tabs

Browse source
This commit is contained in:
Philippe Teuwen 2019-03-09 18:16:50 +01:00
parent 89db6064d0
commit 2b1b76c2a9
53 changed files with 1030 additions and 1029 deletions
Download patch file Download diff file Expand all files Collapse all files

12
liblua/lapi.c
View file

@ -35,21 +35,21 @@ const char lua_ident[] =
/* value at a non-valid index */ /* value at a non-valid index */
#define NONVALIDVALUE cast(TValue *, luaO_nilobject) #define NONVALIDVALUE cast(TValue *, luaO_nilobject)
/* corresponding test */ /* corresponding test */
#define isvalid(o) ((o) != luaO_nilobject) #define isvalid(o) ((o) != luaO_nilobject)
/* test for pseudo index */ /* test for pseudo index */
#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) #define ispseudo(i) ((i) <= LUA_REGISTRYINDEX)
/* test for valid but not pseudo index */ /* test for valid but not pseudo index */
#define isstackindex(i, o) (isvalid(o) && !ispseudo(i)) #define isstackindex(i, o) (isvalid(o) && !ispseudo(i))
#define api_checkvalidindex(L, o) api_check(L, isvalid(o), "invalid index") #define api_checkvalidindex(L, o) api_check(L, isvalid(o), "invalid index")
#define api_checkstackindex(L, i, o) \ #define api_checkstackindex(L, i, o) \
api_check(L, isstackindex(i, o), "index not in the stack") api_check(L, isstackindex(i, o), "index not in the stack")
static TValue *index2addr (lua_State *L, int idx) { static TValue *index2addr (lua_State *L, int idx) {
@ -874,7 +874,7 @@ LUA_API void lua_setuservalue (lua_State *L, int idx) {
#define checkresults(L,na,nr) \ #define checkresults(L,na,nr) \
api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \ api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
"results from function overflow current stack size") "results from function overflow current stack size")
LUA_API int lua_getctx (lua_State *L, int *ctx) { LUA_API int lua_getctx (lua_State *L, int *ctx) {

6
liblua/lapi.h
View file

@ -12,13 +12,13 @@
#include "lstate.h" #include "lstate.h"
#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \ #define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \
"stack overflow");} "stack overflow");}
#define adjustresults(L,nres) \ #define adjustresults(L,nres) \
{ if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; } { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
#define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \ #define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \
"not enough elements in the stack") "not enough elements in the stack")
#endif #endif

12
liblua/lauxlib.c
View file

@ -31,8 +31,8 @@
*/ */
#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 */
@ -222,7 +222,7 @@ LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
} }
#if !defined(inspectstat) /* { */ #if !defined(inspectstat) /* { */
#if defined(LUA_USE_POSIX) #if defined(LUA_USE_POSIX)
@ -241,7 +241,7 @@ LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
#endif #endif
#endif /* } */ #endif /* } */
LUALIB_API int luaL_execresult (lua_State *L, int stat) { LUALIB_API int luaL_execresult (lua_State *L, int stat) {
@ -428,7 +428,7 @@ LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg,
** check whether buffer is using a userdata on the stack as a temporary ** check whether buffer is using a userdata on the stack as a temporary
** buffer ** buffer
*/ */
#define buffonstack(B) ((B)->b != (B)->initb) #define buffonstack(B) ((B)->b != (B)->initb)
/* /*
@ -516,7 +516,7 @@ LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {
*/ */
/* index of free-list header */ /* index of free-list header */
#define freelist 0 #define freelist 0
LUALIB_API int luaL_ref (lua_State *L, int t) { LUALIB_API int luaL_ref (lua_State *L, int t) {

42
liblua/lauxlib.h
View file

@ -27,7 +27,7 @@ typedef struct luaL_Reg {
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver); LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM) #define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM)
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
@ -75,7 +75,7 @@ LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
const char *mode); const char *mode);
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) #define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
const char *name, const char *mode); const char *name, const char *mode);
@ -105,33 +105,33 @@ LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
*/ */
#define luaL_newlibtable(L,l) \ #define luaL_newlibtable(L,l) \
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
#define luaL_newlib(L,l) (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) #define luaL_newlib(L,l) (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
#define luaL_argcheck(L, cond,numarg,extramsg) \ #define luaL_argcheck(L, cond,numarg,extramsg) \
((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) #define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) #define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
#define luaL_dofile(L, fn) \ #define luaL_dofile(L, fn) \
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_dostring(L, s) \ #define luaL_dostring(L, s) \
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) #define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) #define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
/* /*
@ -153,7 +153,7 @@ typedef struct luaL_Buffer {
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
((B)->b[(B)->n++] = (c))) ((B)->b[(B)->n++] = (c)))
#define luaL_addsize(B,s) ((B)->n += (s)) #define luaL_addsize(B,s) ((B)->n += (s))
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
@ -164,7 +164,7 @@ LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) #define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
/* }====================================================== */ /* }====================================================== */
@ -202,7 +202,7 @@ LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname, LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
const luaL_Reg *l, int nup); const luaL_Reg *l, int nup);
#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0)) #define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0))
#endif #endif

4
liblua/lbaselib.c
View file

@ -43,7 +43,7 @@ static int luaB_print (lua_State *L) {
} }
#define SPACECHARS " \f\n\r\t\v" #define SPACECHARS " \f\n\r\t\v"
static int luaB_tonumber (lua_State *L) { static int luaB_tonumber (lua_State *L) {
if (lua_isnoneornil(L, 2)) { /* standard conversion */ if (lua_isnoneornil(L, 2)) { /* standard conversion */
@ -280,7 +280,7 @@ static int luaB_loadfile (lua_State *L) {
** string to avoid it being collected while parsed. 'load' has four ** string to avoid it being collected while parsed. 'load' has four
** optional arguments (chunk, source name, mode, and environment). ** optional arguments (chunk, source name, mode, and environment).
*/ */
#define RESERVEDSLOT 5 #define RESERVEDSLOT 5
/* /*

8
liblua/lbitlib.c
View file

@ -15,18 +15,18 @@
/* number of bits to consider in a number */ /* number of bits to consider in a number */
#if !defined(LUA_NBITS) #if !defined(LUA_NBITS)
#define LUA_NBITS 32 #define LUA_NBITS 32
#endif #endif
#define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1)) #define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
/* macro to trim extra bits */ /* macro to trim extra bits */
#define trim(x) ((x) & ALLONES) #define trim(x) ((x) & ALLONES)
/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */ /* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
#define mask(n) (~((ALLONES << 1) << ((n) - 1))) #define mask(n) (~((ALLONES << 1) << ((n) - 1)))
typedef lua_Unsigned b_uint; typedef lua_Unsigned b_uint;

2
liblua/lcode.c
View file

@ -26,7 +26,7 @@
#include "lvm.h" #include "lvm.h"
#define hasjumps(e) ((e)->t != (e)->f) #define hasjumps(e) ((e)->t != (e)->f)
static int isnumeral(expdesc *e) { static int isnumeral(expdesc *e) {

8
liblua/lcode.h
View file

@ -36,13 +36,13 @@ typedef enum BinOpr {
typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
#define getcode(fs,e) ((fs)->f->code[(e)->u.info]) #define getcode(fs,e) ((fs)->f->code[(e)->u.info])
#define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) #define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)
LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);

36
liblua/lctype.c
View file

@ -9,44 +9,44 @@
#include "lctype.h" #include "lctype.h"
#if !LUA_USE_CTYPE /* { */ #if !LUA_USE_CTYPE /* { */
#include <limits.h> #include <limits.h>
LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = { LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
0x00, /* EOZ */ 0x00, /* EOZ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */
0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */ 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */
0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */ 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05,
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */ 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
#endif /* } */ #endif /* } */

52
liblua/lctype.h
View file

@ -20,58 +20,58 @@
#if 'A' == 65 && '0' == 48 #if 'A' == 65 && '0' == 48
/* ASCII case: can use its own tables; faster and fixed */ /* ASCII case: can use its own tables; faster and fixed */
#define LUA_USE_CTYPE 0 #define LUA_USE_CTYPE 0
#else #else
/* must use standard C ctype */ /* must use standard C ctype */
#define LUA_USE_CTYPE 1 #define LUA_USE_CTYPE 1
#endif #endif
#endif #endif
#if !LUA_USE_CTYPE /* { */ #if !LUA_USE_CTYPE /* { */
#include <limits.h> #include <limits.h>
#include "llimits.h" #include "llimits.h"
#define ALPHABIT 0 #define ALPHABIT 0
#define DIGITBIT 1 #define DIGITBIT 1
#define PRINTBIT 2 #define PRINTBIT 2
#define SPACEBIT 3 #define SPACEBIT 3
#define XDIGITBIT 4 #define XDIGITBIT 4
#define MASK(B) (1 << (B)) #define MASK(B) (1 << (B))
/* /*
** add 1 to char to allow index -1 (EOZ) ** add 1 to char to allow index -1 (EOZ)
*/ */
#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) #define testprop(c,p) (luai_ctype_[(c)+1] & (p))
/* /*
** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_' ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
*/ */
#define lislalpha(c) testprop(c, MASK(ALPHABIT)) #define lislalpha(c) testprop(c, MASK(ALPHABIT))
#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) #define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
#define lisdigit(c) testprop(c, MASK(DIGITBIT)) #define lisdigit(c) testprop(c, MASK(DIGITBIT))
#define lisspace(c) testprop(c, MASK(SPACEBIT)) #define lisspace(c) testprop(c, MASK(SPACEBIT))
#define lisprint(c) testprop(c, MASK(PRINTBIT)) #define lisprint(c) testprop(c, MASK(PRINTBIT))
#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) #define lisxdigit(c) testprop(c, MASK(XDIGITBIT))
/* /*
** this 'ltolower' only works for alphabetic characters ** this 'ltolower' only works for alphabetic characters
*/ */
#define ltolower(c) ((c) | ('A' ^ 'a')) #define ltolower(c) ((c) | ('A' ^ 'a'))
/* two more entries for 0 and -1 (EOZ) */ /* two more entries for 0 and -1 (EOZ) */
LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2]; LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
#else /* }{ */ #else /* }{ */
/* /*
** use standard C ctypes ** use standard C ctypes
@ -80,16 +80,16 @@ LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
#include <ctype.h> #include <ctype.h>
#define lislalpha(c) (isalpha(c) || (c) == '_') #define lislalpha(c) (isalpha(c) || (c) == '_')
#define lislalnum(c) (isalnum(c) || (c) == '_') #define lislalnum(c) (isalnum(c) || (c) == '_')
#define lisdigit(c) (isdigit(c)) #define lisdigit(c) (isdigit(c))
#define lisspace(c) (isspace(c)) #define lisspace(c) (isspace(c))
#define lisprint(c) (isprint(c)) #define lisprint(c) (isprint(c))
#define lisxdigit(c) (isxdigit(c)) #define lisxdigit(c) (isxdigit(c))
#define ltolower(c) (tolower(c)) #define ltolower(c) (tolower(c))
#endif /* } */ #endif /* } */
#endif #endif

4
liblua/ldblib.c
View file

@ -18,7 +18,7 @@
#include "lualib.h" #include "lualib.h"
#define HOOKKEY "_HKEY" #define HOOKKEY "_HKEY"
@ -253,7 +253,7 @@ static int db_upvaluejoin (lua_State *L) {
} }
#define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY) #define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)
static void hookf (lua_State *L, lua_Debug *ar) { static void hookf (lua_State *L, lua_Debug *ar) {

2
liblua/ldebug.c
View file

@ -30,7 +30,7 @@
#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL) #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL)
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name); static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);

8
liblua/ldebug.h
View file

@ -11,14 +11,14 @@
#include "lstate.h" #include "lstate.h"
#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) #define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)
#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) #define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
#define resethookcount(L) (L->hookcount = L->basehookcount) #define resethookcount(L) (L->hookcount = L->basehookcount)
/* Active Lua function (given call info) */ /* Active Lua function (given call info) */
#define ci_func(ci) (clLvalue((ci)->func)) #define ci_func(ci) (clLvalue((ci)->func))
LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,

20
liblua/ldo.c
View file

@ -50,22 +50,22 @@
#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) #if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)
/* C++ exceptions */ /* C++ exceptions */
#define LUAI_THROW(L,c) throw(c) #define LUAI_THROW(L,c) throw(c)
#define LUAI_TRY(L,c,a) \ #define LUAI_TRY(L,c,a) \
try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; } try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
#define luai_jmpbuf int /* dummy variable */ #define luai_jmpbuf int /* dummy variable */
#elif defined(LUA_USE_ULONGJMP) #elif defined(LUA_USE_ULONGJMP)
/* in Unix, try _longjmp/_setjmp (more efficient) */ /* in Unix, try _longjmp/_setjmp (more efficient) */
#define LUAI_THROW(L,c) _longjmp((c)->b, 1) #define LUAI_THROW(L,c) _longjmp((c)->b, 1)
#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } #define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
#define luai_jmpbuf jmp_buf #define luai_jmpbuf jmp_buf
#else #else
/* default handling with long jumps */ /* default handling with long jumps */
#define LUAI_THROW(L,c) longjmp((c)->b, 1) #define LUAI_THROW(L,c) longjmp((c)->b, 1)
#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } #define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
#define luai_jmpbuf jmp_buf #define luai_jmpbuf jmp_buf
#endif #endif
@ -155,7 +155,7 @@ static void correctstack (lua_State *L, TValue *oldstack) {
/* some space for error handling */ /* some space for error handling */
#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) #define ERRORSTACKSIZE (LUAI_MAXSTACK + 200)
void luaD_reallocstack (lua_State *L, int newsize) { void luaD_reallocstack (lua_State *L, int newsize) {

8
liblua/ldo.h
View file

@ -13,14 +13,14 @@
#include "lzio.h" #include "lzio.h"
#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \ #define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \
luaD_growstack(L, n); else condmovestack(L); luaD_growstack(L, n); else condmovestack(L);
#define incr_top(L) {L->top++; luaD_checkstack(L,0);} #define incr_top(L) {L->top++; luaD_checkstack(L,0);}
#define savestack(L,p) ((char *)(p) - (char *)L->stack) #define savestack(L,p) ((char *)(p) - (char *)L->stack)
#define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) #define restorestack(L,n) ((TValue *)((char *)L->stack + (n)))
/* type of protected functions, to be ran by `runprotected' */ /* type of protected functions, to be ran by `runprotected' */

22
liblua/ldump.c
View file

@ -23,8 +23,8 @@ typedef struct {
int status; int status;
} DumpState; } DumpState;
#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D) #define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D)
#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D) #define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D)
static void DumpBlock(const void* b, size_t size, DumpState* D) static void DumpBlock(const void* b, size_t size, DumpState* D)
{ {
@ -67,13 +67,13 @@ static void DumpString(const TString* s, DumpState* D)
} }
else else
{ {
size_t size=s->tsv.len+1; /* include trailing '\0' */ size_t size=s->tsv.len+1; /* include trailing '\0' */
DumpVar(size,D); DumpVar(size,D);
DumpBlock(getstr(s),size*sizeof(char),D); DumpBlock(getstr(s),size*sizeof(char),D);
} }
} }
#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D) #define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
static void DumpFunction(const Proto* f, DumpState* D); static void DumpFunction(const Proto* f, DumpState* D);
@ -88,16 +88,16 @@ static void DumpConstants(const Proto* f, DumpState* D)
switch (ttypenv(o)) switch (ttypenv(o))
{ {
case LUA_TNIL: case LUA_TNIL:
break; break;
case LUA_TBOOLEAN: case LUA_TBOOLEAN:
DumpChar(bvalue(o),D); DumpChar(bvalue(o),D);
break; break;
case LUA_TNUMBER: case LUA_TNUMBER:
DumpNumber(nvalue(o),D); DumpNumber(nvalue(o),D);
break; break;
case LUA_TSTRING: case LUA_TSTRING:
DumpString(rawtsvalue(o),D); DumpString(rawtsvalue(o),D);
break; break;
default: lua_assert(0); default: lua_assert(0);
} }
} }

4
liblua/lfunc.h
View file

@ -11,10 +11,10 @@
#include "lobject.h" #include "lobject.h"
#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \ #define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \
cast(int, sizeof(TValue)*((n)-1))) cast(int, sizeof(TValue)*((n)-1)))
#define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \ #define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \
cast(int, sizeof(TValue *)*((n)-1))) cast(int, sizeof(TValue *)*((n)-1)))

32
liblua/lgc.c
View file

@ -28,44 +28,44 @@
** cost of sweeping one element (the size of a small object divided ** cost of sweeping one element (the size of a small object divided
** by some adjust for the sweep speed) ** by some adjust for the sweep speed)
*/ */
#define GCSWEEPCOST ((sizeof(TString) + 4) / 4) #define GCSWEEPCOST ((sizeof(TString) + 4) / 4)
/* maximum number of elements to sweep in each single step */ /* maximum number of elements to sweep in each single step */
#define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4)) #define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
/* maximum number of finalizers to call in each GC step */ /* maximum number of finalizers to call in each GC step */
#define GCFINALIZENUM 4 #define GCFINALIZENUM 4
/* /*
** macro to adjust 'stepmul': 'stepmul' is actually used like ** macro to adjust 'stepmul': 'stepmul' is actually used like
** 'stepmul / STEPMULADJ' (value chosen by tests) ** 'stepmul / STEPMULADJ' (value chosen by tests)
*/ */
#define STEPMULADJ 200 #define STEPMULADJ 200
/* /*
** macro to adjust 'pause': 'pause' is actually used like ** macro to adjust 'pause': 'pause' is actually used like
** 'pause / PAUSEADJ' (value chosen by tests) ** 'pause / PAUSEADJ' (value chosen by tests)
*/ */
#define PAUSEADJ 100 #define PAUSEADJ 100
/* /*
** 'makewhite' erases all color bits plus the old bit and then ** 'makewhite' erases all color bits plus the old bit and then
** sets only the current white bit ** sets only the current white bit
*/ */
#define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS)) #define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS))
#define makewhite(g,x) \ #define makewhite(g,x) \
(gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g))) (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g)))
#define white2gray(x) resetbits(gch(x)->marked, WHITEBITS) #define white2gray(x) resetbits(gch(x)->marked, WHITEBITS)
#define black2gray(x) resetbit(gch(x)->marked, BLACKBIT) #define black2gray(x) resetbit(gch(x)->marked, BLACKBIT)
#define isfinalized(x) testbit(gch(x)->marked, FINALIZEDBIT) #define isfinalized(x) testbit(gch(x)->marked, FINALIZEDBIT)
#define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n))) #define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
#define checkconsistency(obj) \ #define checkconsistency(obj) \
@ -76,7 +76,7 @@
if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \ #define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \
reallymarkobject(g, obj2gco(t)); } reallymarkobject(g, obj2gco(t)); }
static void reallymarkobject (global_State *g, GCObject *o); static void reallymarkobject (global_State *g, GCObject *o);
@ -91,13 +91,13 @@ static void reallymarkobject (global_State *g, GCObject *o);
/* /*
** one after last element in a hash array ** one after last element in a hash array
*/ */
#define gnodelast(h) gnode(h, cast(size_t, sizenode(h))) #define gnodelast(h) gnode(h, cast(size_t, sizenode(h)))
/* /*
** link table 'h' into list pointed by 'p' ** link table 'h' into list pointed by 'p'
*/ */
#define linktable(h,p) ((h)->gclist = *(p), *(p) = obj2gco(h)) #define linktable(h,p) ((h)->gclist = *(p), *(p) = obj2gco(h))
/* /*
@ -680,7 +680,7 @@ static void freeobj (lua_State *L, GCObject *o) {
} }
#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM) #define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count); static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count);
@ -915,7 +915,7 @@ static void setpause (global_State *g, l_mem estimate) {
#define sweepphases \ #define sweepphases \
(bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep)) (bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep))
/* /*

84
liblua/lgc.h
View file

@ -29,25 +29,25 @@
/* how much to allocate before next GC step */ /* how much to allocate before next GC step */
#if !defined(GCSTEPSIZE) #if !defined(GCSTEPSIZE)
/* ~100 small strings */ /* ~100 small strings */
#define GCSTEPSIZE (cast_int(100 * sizeof(TString))) #define GCSTEPSIZE (cast_int(100 * sizeof(TString)))
#endif #endif
/* /*
** Possible states of the Garbage Collector ** Possible states of the Garbage Collector
*/ */
#define GCSpropagate 0 #define GCSpropagate 0
#define GCSatomic 1 #define GCSatomic 1
#define GCSsweepstring 2 #define GCSsweepstring 2
#define GCSsweepudata 3 #define GCSsweepudata 3
#define GCSsweep 4 #define GCSsweep 4
#define GCSpause 5 #define GCSpause 5
#define issweepphase(g) \ #define issweepphase(g) \
(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep) (GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)
#define isgenerational(g) ((g)->gckind == KGC_GEN) #define isgenerational(g) ((g)->gckind == KGC_GEN)
/* /*
** macros to tell when main invariant (white objects cannot point to black ** macros to tell when main invariant (white objects cannot point to black
@ -58,7 +58,7 @@
** invariant must be kept all times. ** invariant must be kept all times.
*/ */
#define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic) #define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic)
/* /*
@ -73,66 +73,66 @@
/* /*
** some useful bit tricks ** some useful bit tricks
*/ */
#define resetbits(x,m) ((x) &= cast(lu_byte, ~(m))) #define resetbits(x,m) ((x) &= cast(lu_byte, ~(m)))
#define setbits(x,m) ((x) |= (m)) #define setbits(x,m) ((x) |= (m))
#define testbits(x,m) ((x) & (m)) #define testbits(x,m) ((x) & (m))
#define bitmask(b) (1<<(b)) #define bitmask(b) (1<<(b))
#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
#define l_setbit(x,b) setbits(x, bitmask(b)) #define l_setbit(x,b) setbits(x, bitmask(b))
#define resetbit(x,b) resetbits(x, bitmask(b)) #define resetbit(x,b) resetbits(x, bitmask(b))
#define testbit(x,b) testbits(x, bitmask(b)) #define testbit(x,b) testbits(x, bitmask(b))
/* Layout for bit use in `marked' field: */ /* Layout for bit use in `marked' field: */
#define WHITE0BIT 0 /* object is white (type 0) */ #define WHITE0BIT 0 /* object is white (type 0) */
#define WHITE1BIT 1 /* object is white (type 1) */ #define WHITE1BIT 1 /* object is white (type 1) */
#define BLACKBIT 2 /* object is black */ #define BLACKBIT 2 /* object is black */
#define FINALIZEDBIT 3 /* object has been separated for finalization */ #define FINALIZEDBIT 3 /* object has been separated for finalization */
#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */ #define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */
#define FIXEDBIT 5 /* object is fixed (should not be collected) */ #define FIXEDBIT 5 /* object is fixed (should not be collected) */
#define OLDBIT 6 /* object is old (only in generational mode) */ #define OLDBIT 6 /* object is old (only in generational mode) */
/* bit 7 is currently used by tests (luaL_checkmemory) */ /* bit 7 is currently used by tests (luaL_checkmemory) */
#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
#define iswhite(x) testbits((x)->gch.marked, WHITEBITS) #define iswhite(x) testbits((x)->gch.marked, WHITEBITS)
#define isblack(x) testbit((x)->gch.marked, BLACKBIT) #define isblack(x) testbit((x)->gch.marked, BLACKBIT)
#define isgray(x) /* neither white nor black */ \ #define isgray(x) /* neither white nor black */ \
(!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT))) (!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT)))
#define isold(x) testbit((x)->gch.marked, OLDBIT) #define isold(x) testbit((x)->gch.marked, OLDBIT)
/* MOVE OLD rule: whenever an object is moved to the beginning of /* MOVE OLD rule: whenever an object is moved to the beginning of
a GC list, its old bit must be cleared */ a GC list, its old bit must be cleared */
#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT) #define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT)
#define otherwhite(g) (g->currentwhite ^ WHITEBITS) #define otherwhite(g) (g->currentwhite ^ WHITEBITS)
#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow))) #define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked) #define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)
#define changewhite(x) ((x)->gch.marked ^= WHITEBITS) #define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT) #define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
#define luaC_condGC(L,c) \ #define luaC_condGC(L,c) \
{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);} {if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);) #define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)
#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \
luaC_barrier_(L,obj2gco(p),gcvalue(v)); } luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ #define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \
luaC_barrierback_(L,p); } luaC_barrierback_(L,p); }
#define luaC_objbarrier(L,p,o) \ #define luaC_objbarrier(L,p,o) \
{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
luaC_barrier_(L,obj2gco(p),obj2gco(o)); } luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
#define luaC_objbarrierback(L,p,o) \ #define luaC_objbarrierback(L,p,o) \
{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); } { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }

68
liblua/liolib.c
View file

@ -37,10 +37,10 @@
** the standard ones. ** the standard ones.
*/ */
#define lua_checkmode(mode) \ #define lua_checkmode(mode) \
(*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \ (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \
(*mode != '+' || ++mode) && /* skip if char is '+' */ \ (*mode != '+' || ++mode) && /* skip if char is '+' */ \
(*mode != 'b' || ++mode) && /* skip if char is 'b' */ \ (*mode != 'b' || ++mode) && /* skip if char is 'b' */ \
(*mode == '\0')) (*mode == '\0'))
#endif #endif
@ -51,29 +51,29 @@
** ======================================================= ** =======================================================
*/ */
#if !defined(lua_popen) /* { */ #if !defined(lua_popen) /* { */
#if defined(LUA_USE_POPEN) /* { */ #if defined(LUA_USE_POPEN) /* { */
#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) #define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))
#define lua_pclose(L,file) ((void)L, pclose(file)) #define lua_pclose(L,file) ((void)L, pclose(file))
#elif defined(LUA_WIN) /* }{ */ #elif defined(LUA_WIN) /* }{ */
#define lua_popen(L,c,m) ((void)L, _popen(c,m)) #define lua_popen(L,c,m) ((void)L, _popen(c,m))
#define lua_pclose(L,file) ((void)L, _pclose(file)) #define lua_pclose(L,file) ((void)L, _pclose(file))
#else /* }{ */ #else /* }{ */
#define lua_popen(L,c,m) ((void)((void)c, m), \ #define lua_popen(L,c,m) ((void)((void)c, m), \
luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
#define lua_pclose(L,file) ((void)((void)L, file), -1) #define lua_pclose(L,file) ((void)((void)L, file), -1)
#endif /* } */ #endif /* } */
#endif /* } */ #endif /* } */
/* }====================================================== */ /* }====================================================== */
@ -84,46 +84,46 @@
** ======================================================= ** =======================================================
*/ */
#if !defined(lua_fseek) /* { */ #if !defined(lua_fseek) /* { */
#if defined(LUA_USE_POSIX) #if defined(LUA_USE_POSIX)
#define l_fseek(f,o,w) fseeko(f,o,w) #define l_fseek(f,o,w) fseeko(f,o,w)
#define l_ftell(f) ftello(f) #define l_ftell(f) ftello(f)
#define l_seeknum off_t #define l_seeknum off_t
#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \ #elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
&& defined(_MSC_VER) && (_MSC_VER >= 1400) && defined(_MSC_VER) && (_MSC_VER >= 1400)
/* Windows (but not DDK) and Visual C++ 2005 or higher */ /* Windows (but not DDK) and Visual C++ 2005 or higher */
#define l_fseek(f,o,w) _fseeki64(f,o,w) #define l_fseek(f,o,w) _fseeki64(f,o,w)
#define l_ftell(f) _ftelli64(f) #define l_ftell(f) _ftelli64(f)
#define l_seeknum __int64 #define l_seeknum __int64
#else #else
#define l_fseek(f,o,w) fseek(f,o,w) #define l_fseek(f,o,w) fseek(f,o,w)
#define l_ftell(f) ftell(f) #define l_ftell(f) ftell(f)
#define l_seeknum long #define l_seeknum long
#endif #endif
#endif /* } */ #endif /* } */
/* }====================================================== */ /* }====================================================== */
#define IO_PREFIX "_IO_" #define IO_PREFIX "_IO_"
#define IO_INPUT (IO_PREFIX "input") #define IO_INPUT (IO_PREFIX "input")
#define IO_OUTPUT (IO_PREFIX "output") #define IO_OUTPUT (IO_PREFIX "output")
typedef luaL_Stream LStream; typedef luaL_Stream LStream;
#define tolstream(L) ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE)) #define tolstream(L) ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
#define isclosed(p) ((p)->closef == NULL) #define isclosed(p) ((p)->closef == NULL)
static int io_type (lua_State *L) { static int io_type (lua_State *L) {
@ -389,7 +389,7 @@ static int read_line (lua_State *L, FILE *f, int chop) {
} }
#define MAX_SIZE_T (~(size_t)0) #define MAX_SIZE_T (~(size_t)0)
static void read_all (lua_State *L, FILE *f) { static void read_all (lua_State *L, FILE *f) {
size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */ size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */

6
liblua/llex.c
View file

@ -29,7 +29,7 @@
#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') #define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
/* ORDER RESERVED */ /* ORDER RESERVED */
@ -201,11 +201,11 @@ static void buffreplace (LexState *ls, char from, char to) {
#if ANDROID #if ANDROID
#define getlocaldecpoint() '.' #define getlocaldecpoint() '.'
#elif !defined(getlocaledecpoint) #elif !defined(getlocaledecpoint)
#define getlocaledecpoint() (localeconv()->decimal_point[0]) #define getlocaledecpoint() (localeconv()->decimal_point[0])
#endif #endif
#define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e) #define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)
/* /*
** in case of format error, try to change decimal point separator to ** in case of format error, try to change decimal point separator to

4
liblua/llex.h
View file

@ -11,7 +11,7 @@
#include "lzio.h" #include "lzio.h"
#define FIRST_RESERVED 257 #define FIRST_RESERVED 257
@ -31,7 +31,7 @@ enum RESERVED {
}; };
/* number of reserved words */ /* number of reserved words */
#define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1)) #define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1))
typedef union { typedef union {

112
liblua/llimits.h
View file

@ -27,11 +27,11 @@ typedef LUAI_MEM l_mem;
typedef unsigned char lu_byte; typedef unsigned char lu_byte;
#define MAX_SIZET ((size_t)(~(size_t)0)-2) #define MAX_SIZET ((size_t)(~(size_t)0)-2)
#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2) #define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2)
#define MAX_LMEM ((l_mem) ((MAX_LUMEM >> 1) - 2)) #define MAX_LMEM ((l_mem) ((MAX_LUMEM >> 1) - 2))
#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ #define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */
@ -47,7 +47,7 @@ typedef unsigned char lu_byte;
/* type to ensure maximum alignment */ /* type to ensure maximum alignment */
#if !defined(LUAI_USER_ALIGNMENT_T) #if !defined(LUAI_USER_ALIGNMENT_T)
#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } #define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; }
#endif #endif
typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
@ -59,13 +59,13 @@ typedef LUAI_UACNUMBER l_uacNumber;
/* internal assertions for in-house debugging */ /* internal assertions for in-house debugging */
#if defined(lua_assert) #if defined(lua_assert)
#define check_exp(c,e) (lua_assert(c), (e)) #define check_exp(c,e) (lua_assert(c), (e))
/* to avoid problems with conditions too long */ /* to avoid problems with conditions too long */
#define lua_longassert(c) { if (!(c)) lua_assert(0); } #define lua_longassert(c) { if (!(c)) lua_assert(0); }
#else #else
#define lua_assert(c) ((void)0) #define lua_assert(c) ((void)0)
#define check_exp(c,e) (e) #define check_exp(c,e) (e)
#define lua_longassert(c) ((void)0) #define lua_longassert(c) ((void)0)
#endif #endif
/* /*
@ -75,38 +75,38 @@ typedef LUAI_UACNUMBER l_uacNumber;
#if defined(LUA_USE_APICHECK) #if defined(LUA_USE_APICHECK)
#include <assert.h> #include <assert.h>
#define luai_apicheck(L,e) assert(e) #define luai_apicheck(L,e) assert(e)
#else #else
#define luai_apicheck(L,e) lua_assert(e) #define luai_apicheck(L,e) lua_assert(e)
#endif #endif
#endif #endif
#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) #define api_check(l,e,msg) luai_apicheck(l,(e) && msg)
#if !defined(UNUSED) #if !defined(UNUSED)
#define UNUSED(x) ((void)(x)) /* to avoid warnings */ #define UNUSED(x) ((void)(x)) /* to avoid warnings */
#endif #endif
#define cast(t, exp) ((t)(exp)) #define cast(t, exp) ((t)(exp))
#define cast_byte(i) cast(lu_byte, (i)) #define cast_byte(i) cast(lu_byte, (i))
#define cast_num(i) cast(lua_Number, (i)) #define cast_num(i) cast(lua_Number, (i))
#define cast_int(i) cast(int, (i)) #define cast_int(i) cast(int, (i))
#define cast_uchar(i) cast(unsigned char, (i)) #define cast_uchar(i) cast(unsigned char, (i))
/* /*
** non-return type ** non-return type
*/ */
#if defined(__GNUC__) #if defined(__GNUC__)
#define l_noret void __attribute__((noreturn)) #define l_noret void __attribute__((noreturn))
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
#define l_noret void __declspec(noreturn) #define l_noret void __declspec(noreturn)
#else #else
#define l_noret void #define l_noret void
#endif #endif
@ -116,14 +116,14 @@ typedef LUAI_UACNUMBER l_uacNumber;
** in a program. (Value must fit in an unsigned short int.) ** in a program. (Value must fit in an unsigned short int.)
*/ */
#if !defined(LUAI_MAXCCALLS) #if !defined(LUAI_MAXCCALLS)
#define LUAI_MAXCCALLS 200 #define LUAI_MAXCCALLS 200
#endif #endif
/* /*
** maximum number of upvalues in a closure (both C and Lua). (Value ** maximum number of upvalues in a closure (both C and Lua). (Value
** must fit in an unsigned char.) ** must fit in an unsigned char.)
*/ */
#define MAXUPVAL UCHAR_MAX #define MAXUPVAL UCHAR_MAX
/* /*
@ -135,19 +135,19 @@ typedef lu_int32 Instruction;
/* maximum stack for a Lua function */ /* maximum stack for a Lua function */
#define MAXSTACK 250 #define MAXSTACK 250
/* minimum size for the string table (must be power of 2) */ /* minimum size for the string table (must be power of 2) */
#if !defined(MINSTRTABSIZE) #if !defined(MINSTRTABSIZE)
#define MINSTRTABSIZE 32 #define MINSTRTABSIZE 32
#endif #endif
/* minimum size for string buffer */ /* minimum size for string buffer */
#if !defined(LUA_MINBUFFER) #if !defined(LUA_MINBUFFER)
#define LUA_MINBUFFER 32 #define LUA_MINBUFFER 32
#endif #endif
@ -167,27 +167,27 @@ typedef lu_int32 Instruction;
** created/deleted/resumed/yielded. ** created/deleted/resumed/yielded.
*/ */
#if !defined(luai_userstateopen) #if !defined(luai_userstateopen)
#define luai_userstateopen(L) ((void)L) #define luai_userstateopen(L) ((void)L)
#endif #endif
#if !defined(luai_userstateclose) #if !defined(luai_userstateclose)
#define luai_userstateclose(L) ((void)L) #define luai_userstateclose(L) ((void)L)
#endif #endif
#if !defined(luai_userstatethread) #if !defined(luai_userstatethread)
#define luai_userstatethread(L,L1) ((void)L) #define luai_userstatethread(L,L1) ((void)L)
#endif #endif
#if !defined(luai_userstatefree) #if !defined(luai_userstatefree)
#define luai_userstatefree(L,L1) ((void)L) #define luai_userstatefree(L,L1) ((void)L)
#endif #endif
#if !defined(luai_userstateresume) #if !defined(luai_userstateresume)
#define luai_userstateresume(L,n) ((void)L) #define luai_userstateresume(L,n) ((void)L)
#endif #endif
#if !defined(luai_userstateyield) #if !defined(luai_userstateyield)
#define luai_userstateyield(L,n) ((void)L) #define luai_userstateyield(L,n) ((void)L)
#endif #endif
/* /*
@ -200,29 +200,29 @@ typedef lu_int32 Instruction;
** both small and large values (outside the range of integers). ** both small and large values (outside the range of integers).
*/ */
#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */ #if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */
/* trick with Microsoft assembler for X86 */ /* trick with Microsoft assembler for X86 */
#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i} #define lua_number2int(i,n) __asm {__asm fld n __asm fistp i}
#define lua_number2integer(i,n) lua_number2int(i, n) #define lua_number2integer(i,n) lua_number2int(i, n)
#define lua_number2unsigned(i,n) \ #define lua_number2unsigned(i,n) \
{__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;} {__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;}
#elif defined(LUA_IEEE754TRICK) /* }{ */ #elif defined(LUA_IEEE754TRICK) /* }{ */
/* the next trick should work on any machine using IEEE754 with /* the next trick should work on any machine using IEEE754 with
a 32-bit int type */ a 32-bit int type */
union luai_Cast { double l_d; LUA_INT32 l_p[2]; }; union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
#if !defined(LUA_IEEEENDIAN) /* { */ #if !defined(LUA_IEEEENDIAN) /* { */
#define LUAI_EXTRAIEEE \ #define LUAI_EXTRAIEEE \
static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)}; static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33) #define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33)
#else #else
#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN #define LUA_IEEEENDIANLOC LUA_IEEEENDIAN
#define LUAI_EXTRAIEEE /* empty */ #define LUAI_EXTRAIEEE /* empty */
#endif /* } */ #endif /* } */
#define lua_number2int32(i,n,t) \ #define lua_number2int32(i,n,t) \
{ LUAI_EXTRAIEEE \ { LUAI_EXTRAIEEE \
@ -233,38 +233,38 @@ union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
{ volatile union luai_Cast u; u.l_d = (n) + 1.0; /* avoid -0 */ \ { volatile union luai_Cast u; u.l_d = (n) + 1.0; /* avoid -0 */ \
(i) = u.l_p[0]; (i) += u.l_p[1]; } /* add double bits for his hash */ (i) = u.l_p[0]; (i) += u.l_p[1]; } /* add double bits for his hash */
#define lua_number2int(i,n) lua_number2int32(i, n, int) #define lua_number2int(i,n) lua_number2int32(i, n, int)
#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned) #define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned)
/* the trick can be expanded to lua_Integer when it is a 32-bit value */ /* the trick can be expanded to lua_Integer when it is a 32-bit value */
#if defined(LUA_IEEELL) #if defined(LUA_IEEELL)
#define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer) #define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer)
#endif #endif
#endif /* } */ #endif /* } */
/* the following definitions always work, but may be slow */ /* the following definitions always work, but may be slow */
#if !defined(lua_number2int) #if !defined(lua_number2int)
#define lua_number2int(i,n) ((i)=(int)(n)) #define lua_number2int(i,n) ((i)=(int)(n))
#endif #endif
#if !defined(lua_number2integer) #if !defined(lua_number2integer)
#define lua_number2integer(i,n) ((i)=(lua_Integer)(n)) #define lua_number2integer(i,n) ((i)=(lua_Integer)(n))
#endif #endif
#if !defined(lua_number2unsigned) /* { */ #if !defined(lua_number2unsigned) /* { */
/* the following definition assures proper modulo behavior */ /* the following definition assures proper modulo behavior */
#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT) #if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
#include <math.h> #include <math.h>
#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1) #define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1)
#define lua_number2unsigned(i,n) \ #define lua_number2unsigned(i,n) \
((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED)) ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
#else #else
#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n)) #define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n))
#endif #endif
#endif /* } */ #endif /* } */
#if !defined(lua_unsigned2number) #if !defined(lua_unsigned2number)
@ -293,17 +293,17 @@ union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
** macro to control inclusion of some hard tests on stack reallocation ** macro to control inclusion of some hard tests on stack reallocation
*/ */
#if !defined(HARDSTACKTESTS) #if !defined(HARDSTACKTESTS)
#define condmovestack(L) ((void)0) #define condmovestack(L) ((void)0)
#else #else
/* realloc stack keeping its size */ /* realloc stack keeping its size */
#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize) #define condmovestack(L) luaD_reallocstack((L), (L)->stacksize)
#endif #endif
#if !defined(HARDMEMTESTS) #if !defined(HARDMEMTESTS)
#define condchangemem(L) condmovestack(L) #define condchangemem(L) condmovestack(L)
#else #else
#define condchangemem(L) \ #define condchangemem(L) \
((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1))) ((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
#endif #endif
#endif #endif

4
liblua/lmathlib.c
View file

@ -18,8 +18,8 @@
#undef PI #undef PI
#define PI ((lua_Number)(3.1415926535897932384626433832795)) #define PI ((lua_Number)(3.1415926535897932384626433832795))
#define RADIANS_PER_DEGREE ((lua_Number)(PI/180.0)) #define RADIANS_PER_DEGREE ((lua_Number)(PI/180.0))

2
liblua/lmem.c
View file

@ -40,7 +40,7 @@
#define MINSIZEARRAY 4 #define MINSIZEARRAY 4
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems, void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,

12
liblua/lmem.h
View file

@ -26,16 +26,16 @@
(cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \ (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \
luaM_realloc_(L, (b), (on)*(e), (n)*(e))) luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
#define luaM_freearray(L, b, n) luaM_reallocv(L, (b), n, 0, sizeof((b)[0])) #define luaM_freearray(L, b, n) luaM_reallocv(L, (b), n, 0, sizeof((b)[0]))
#define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s)) #define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s))
#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t)))
#define luaM_newvector(L,n,t) \ #define luaM_newvector(L,n,t) \
cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t))) cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
#define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s)) #define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s))
#define luaM_growvector(L,v,nelems,size,t,limit,e) \ #define luaM_growvector(L,v,nelems,size,t,limit,e) \
if ((nelems)+1 > (size)) \ if ((nelems)+1 > (size)) \

44
liblua/loadlib.c
View file

@ -35,17 +35,17 @@
** variables that Lua check to set its paths. ** variables that Lua check to set its paths.
*/ */
#if !defined(LUA_PATH) #if !defined(LUA_PATH)
#define LUA_PATH "LUA_PATH" #define LUA_PATH "LUA_PATH"
#endif #endif
#if !defined(LUA_CPATH) #if !defined(LUA_CPATH)
#define LUA_CPATH "LUA_CPATH" #define LUA_CPATH "LUA_CPATH"
#endif #endif
#define LUA_PATHSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR #define LUA_PATHSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
#define LUA_PATHVERSION LUA_PATH LUA_PATHSUFFIX #define LUA_PATHVERSION LUA_PATH LUA_PATHSUFFIX
#define LUA_CPATHVERSION LUA_CPATH LUA_PATHSUFFIX #define LUA_CPATHVERSION LUA_CPATH LUA_PATHSUFFIX
/* /*
** LUA_PATH_SEP is the character that separates templates in a path. ** LUA_PATH_SEP is the character that separates templates in a path.
@ -57,16 +57,16 @@
** luaopen_ function name. ** luaopen_ function name.
*/ */
#if !defined (LUA_PATH_SEP) #if !defined (LUA_PATH_SEP)
#define LUA_PATH_SEP ";" #define LUA_PATH_SEP ";"
#endif #endif
#if !defined (LUA_PATH_MARK) #if !defined (LUA_PATH_MARK)
#define LUA_PATH_MARK "?" #define LUA_PATH_MARK "?"
#endif #endif
#if !defined (LUA_EXEC_DIR) #if !defined (LUA_EXEC_DIR)
#define LUA_EXEC_DIR "!" #define LUA_EXEC_DIR "!"
#endif #endif
#if !defined (LUA_IGMARK) #if !defined (LUA_IGMARK)
#define LUA_IGMARK "-" #define LUA_IGMARK "-"
#endif #endif
@ -77,32 +77,32 @@
** when searching for a Lua loader. ** when searching for a Lua loader.
*/ */
#if !defined(LUA_CSUBSEP) #if !defined(LUA_CSUBSEP)
#define LUA_CSUBSEP LUA_DIRSEP #define LUA_CSUBSEP LUA_DIRSEP
#endif #endif
#if !defined(LUA_LSUBSEP) #if !defined(LUA_LSUBSEP)
#define LUA_LSUBSEP LUA_DIRSEP #define LUA_LSUBSEP LUA_DIRSEP
#endif #endif
/* prefix for open functions in C libraries */ /* prefix for open functions in C libraries */
#define LUA_POF "luaopen_" #define LUA_POF "luaopen_"
/* separator for open functions in C libraries */ /* separator for open functions in C libraries */
#define LUA_OFSEP "_" #define LUA_OFSEP "_"
/* table (in the registry) that keeps handles for all loaded C libraries */ /* table (in the registry) that keeps handles for all loaded C libraries */
#define CLIBS "_CLIBS" #define CLIBS "_CLIBS"
#define LIB_FAIL "open" #define LIB_FAIL "open"
/* error codes for ll_loadfunc */ /* error codes for ll_loadfunc */
#define ERRLIB 1 #define ERRLIB 1
#define ERRFUNC 2 #define ERRFUNC 2
#define setprogdir(L) ((void)0) #define setprogdir(L) ((void)0)
/* /*
@ -161,7 +161,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
** optional flags for LoadLibraryEx ** optional flags for LoadLibraryEx
*/ */
#if !defined(LUA_LLE_FLAGS) #if !defined(LUA_LLE_FLAGS)
#define LUA_LLE_FLAGS 0 #define LUA_LLE_FLAGS 0
#endif #endif
@ -220,10 +220,10 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
*/ */
#undef LIB_FAIL #undef LIB_FAIL
#define LIB_FAIL "absent" #define LIB_FAIL "absent"
#define DLMSG "dynamic libraries not enabled; check your Lua installation" #define DLMSG "dynamic libraries not enabled; check your Lua installation"
static void ll_unloadlib (void *lib) { static void ll_unloadlib (void *lib) {
@ -619,7 +619,7 @@ static int ll_seeall (lua_State *L) {
/* auxiliary mark (for internal use) */ /* auxiliary mark (for internal use) */
#define AUXMARK "\1" #define AUXMARK "\1"
/* /*

10
liblua/lobject.c
View file

@ -241,13 +241,13 @@ const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
/* number of chars of a literal string without the ending \0 */ /* number of chars of a literal string without the ending \0 */
#define LL(x) (sizeof(x)/sizeof(char) - 1) #define LL(x) (sizeof(x)/sizeof(char) - 1)
#define RETS "..." #define RETS "..."
#define PRE "[string \"" #define PRE "[string \""
#define POS "\"]" #define POS "\"]"
#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) #define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) )
void luaO_chunkid (char *out, const char *source, size_t bufflen) { void luaO_chunkid (char *out, const char *source, size_t bufflen) {
size_t l = strlen(source); size_t l = strlen(source);

232
liblua/lobject.h
View file

@ -19,14 +19,14 @@
/* /*
** Extra tags for non-values ** Extra tags for non-values
*/ */
#define LUA_TPROTO LUA_NUMTAGS #define LUA_TPROTO LUA_NUMTAGS
#define LUA_TUPVAL (LUA_NUMTAGS+1) #define LUA_TUPVAL (LUA_NUMTAGS+1)
#define LUA_TDEADKEY (LUA_NUMTAGS+2) #define LUA_TDEADKEY (LUA_NUMTAGS+2)
/* /*
** number of all possible tags (including LUA_TNONE but excluding DEADKEY) ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
*/ */
#define LUA_TOTALTAGS (LUA_TUPVAL+2) #define LUA_TOTALTAGS (LUA_TUPVAL+2)
/* /*
@ -36,7 +36,7 @@
** bit 6: whether value is collectable ** bit 6: whether value is collectable
*/ */
#define VARBITS (3 << 4) #define VARBITS (3 << 4)
/* /*
@ -47,21 +47,21 @@
*/ */
/* Variant tags for functions */ /* Variant tags for functions */
#define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */ #define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */
#define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */ #define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */
#define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */ #define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */
/* Variant tags for strings */ /* Variant tags for strings */
#define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */ #define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */
#define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */ #define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */
/* Bit mark for collectable types */ /* Bit mark for collectable types */
#define BIT_ISCOLLECTABLE (1 << 6) #define BIT_ISCOLLECTABLE (1 << 6)
/* mark a tag as collectable */ /* mark a tag as collectable */
#define ctb(t) ((t) | BIT_ISCOLLECTABLE) #define ctb(t) ((t) | BIT_ISCOLLECTABLE)
/* /*
@ -74,7 +74,7 @@ typedef union GCObject GCObject;
** Common Header for all collectable objects (in macro form, to be ** Common Header for all collectable objects (in macro form, to be
** included in other objects) ** included in other objects)
*/ */
#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked #define CommonHeader GCObject *next; lu_byte tt; lu_byte marked
/* /*
@ -92,7 +92,7 @@ typedef struct GCheader {
typedef union Value Value; typedef union Value Value;
#define numfield lua_Number n; /* numbers */ #define numfield lua_Number n; /* numbers */
@ -101,88 +101,88 @@ typedef union Value Value;
** an actual value plus a tag with its type. ** an actual value plus a tag with its type.
*/ */
#define TValuefields Value value_; int tt_ #define TValuefields Value value_; int tt_
typedef struct lua_TValue TValue; typedef struct lua_TValue TValue;
/* macro defining a nil value */ /* macro defining a nil value */
#define NILCONSTANT {NULL}, LUA_TNIL #define NILCONSTANT {NULL}, LUA_TNIL
#define val_(o) ((o)->value_) #define val_(o) ((o)->value_)
#define num_(o) (val_(o).n) #define num_(o) (val_(o).n)
/* raw type tag of a TValue */ /* raw type tag of a TValue */
#define rttype(o) ((o)->tt_) #define rttype(o) ((o)->tt_)
/* tag with no variants (bits 0-3) */ /* tag with no variants (bits 0-3) */
#define novariant(x) ((x) & 0x0F) #define novariant(x) ((x) & 0x0F)
/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */ /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
#define ttype(o) (rttype(o) & 0x3F) #define ttype(o) (rttype(o) & 0x3F)
/* type tag of a TValue with no variants (bits 0-3) */ /* type tag of a TValue with no variants (bits 0-3) */
#define ttypenv(o) (novariant(rttype(o))) #define ttypenv(o) (novariant(rttype(o)))
/* Macros to test type */ /* Macros to test type */
#define checktag(o,t) (rttype(o) == (t)) #define checktag(o,t) (rttype(o) == (t))
#define checktype(o,t) (ttypenv(o) == (t)) #define checktype(o,t) (ttypenv(o) == (t))
#define ttisnumber(o) checktag((o), LUA_TNUMBER) #define ttisnumber(o) checktag((o), LUA_TNUMBER)
#define ttisnil(o) checktag((o), LUA_TNIL) #define ttisnil(o) checktag((o), LUA_TNIL)
#define ttisboolean(o) checktag((o), LUA_TBOOLEAN) #define ttisboolean(o) checktag((o), LUA_TBOOLEAN)
#define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA) #define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA)
#define ttisstring(o) checktype((o), LUA_TSTRING) #define ttisstring(o) checktype((o), LUA_TSTRING)
#define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR)) #define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR))
#define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR)) #define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR))
#define ttistable(o) checktag((o), ctb(LUA_TTABLE)) #define ttistable(o) checktag((o), ctb(LUA_TTABLE))
#define ttisfunction(o) checktype(o, LUA_TFUNCTION) #define ttisfunction(o) checktype(o, LUA_TFUNCTION)
#define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION) #define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION)
#define ttisCclosure(o) checktag((o), ctb(LUA_TCCL)) #define ttisCclosure(o) checktag((o), ctb(LUA_TCCL))
#define ttisLclosure(o) checktag((o), ctb(LUA_TLCL)) #define ttisLclosure(o) checktag((o), ctb(LUA_TLCL))
#define ttislcf(o) checktag((o), LUA_TLCF) #define ttislcf(o) checktag((o), LUA_TLCF)
#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA)) #define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA))
#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD)) #define ttisthread(o) checktag((o), ctb(LUA_TTHREAD))
#define ttisdeadkey(o) checktag((o), LUA_TDEADKEY) #define ttisdeadkey(o) checktag((o), LUA_TDEADKEY)
#define ttisequal(o1,o2) (rttype(o1) == rttype(o2)) #define ttisequal(o1,o2) (rttype(o1) == rttype(o2))
/* Macros to access values */ /* Macros to access values */
#define nvalue(o) check_exp(ttisnumber(o), num_(o)) #define nvalue(o) check_exp(ttisnumber(o), num_(o))
#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) #define gcvalue(o) check_exp(iscollectable(o), val_(o).gc)
#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) #define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p)
#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts) #define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts)
#define tsvalue(o) (&rawtsvalue(o)->tsv) #define tsvalue(o) (&rawtsvalue(o)->tsv)
#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u) #define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u)
#define uvalue(o) (&rawuvalue(o)->uv) #define uvalue(o) (&rawuvalue(o)->uv)
#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl) #define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl)
#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l) #define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c) #define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
#define fvalue(o) check_exp(ttislcf(o), val_(o).f) #define fvalue(o) check_exp(ttislcf(o), val_(o).f)
#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h) #define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h)
#define bvalue(o) check_exp(ttisboolean(o), val_(o).b) #define bvalue(o) check_exp(ttisboolean(o), val_(o).b)
#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th) #define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th)
/* a dead value may get the 'gc' field, but cannot access its contents */ /* a dead value may get the 'gc' field, but cannot access its contents */
#define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc)) #define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) #define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
#define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE) #define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE)
/* Macros for internal tests */ /* Macros for internal tests */
#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt) #define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt)
#define checkliveness(g,obj) \ #define checkliveness(g,obj) \
lua_longassert(!iscollectable(obj) || \ lua_longassert(!iscollectable(obj) || \
(righttt(obj) && !isdead(g,gcvalue(obj)))) (righttt(obj) && !isdead(g,gcvalue(obj))))
/* Macros to set values */ /* Macros to set values */
#define settt_(o,t) ((o)->tt_=(t)) #define settt_(o,t) ((o)->tt_=(t))
#define setnvalue(obj,x) \ #define setnvalue(obj,x) \
{ TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); } { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); }
@ -233,14 +233,14 @@ typedef struct lua_TValue TValue;
val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \ val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
checkliveness(G(L),io); } checkliveness(G(L),io); }
#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) #define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY)
#define setobj(L,obj1,obj2) \ #define setobj(L,obj1,obj2) \
{ const TValue *io2=(obj2); TValue *io1=(obj1); \ { const TValue *io2=(obj2); TValue *io1=(obj1); \
io1->value_ = io2->value_; io1->tt_ = io2->tt_; \ io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
checkliveness(G(L),io1); } checkliveness(G(L),io1); }
/* /*
@ -248,23 +248,23 @@ typedef struct lua_TValue TValue;
*/ */
/* from stack to (same) stack */ /* from stack to (same) stack */
#define setobjs2s setobj #define setobjs2s setobj
/* to stack (not from same stack) */ /* to stack (not from same stack) */
#define setobj2s setobj #define setobj2s setobj
#define setsvalue2s setsvalue #define setsvalue2s setsvalue
#define sethvalue2s sethvalue #define sethvalue2s sethvalue
#define setptvalue2s setptvalue #define setptvalue2s setptvalue
/* from table to same table */ /* from table to same table */
#define setobjt2t setobj #define setobjt2t setobj
/* to table */ /* to table */
#define setobj2t setobj #define setobj2t setobj
/* to new object */ /* to new object */
#define setobj2n setobj #define setobj2n setobj
#define setsvalue2n setsvalue #define setsvalue2n setsvalue
/* check whether a number is valid (useful only for NaN trick) */ /* check whether a number is valid (useful only for NaN trick) */
#define luai_checknum(L,o,c) { /* empty */ } #define luai_checknum(L,o,c) { /* empty */ }
/* /*
@ -282,7 +282,7 @@ typedef struct lua_TValue TValue;
*/ */
/* allows for external implementation for part of the trick */ /* allows for external implementation for part of the trick */
#if !defined(NNMARK) /* { */ #if !defined(NNMARK) /* { */
#if !defined(LUA_IEEEENDIAN) #if !defined(LUA_IEEEENDIAN)
@ -290,70 +290,70 @@ typedef struct lua_TValue TValue;
#endif #endif
#define NNMARK 0x7FF7A500 #define NNMARK 0x7FF7A500
#define NNMASK 0x7FFFFF00 #define NNMASK 0x7FFFFF00
#undef TValuefields #undef TValuefields
#undef NILCONSTANT #undef NILCONSTANT
#if (LUA_IEEEENDIAN == 0) /* { */ #if (LUA_IEEEENDIAN == 0) /* { */
/* little endian */ /* little endian */
#define TValuefields \ #define TValuefields \
union { struct { Value v__; int tt__; } i; double d__; } u union { struct { Value v__; int tt__; } i; double d__; } u
#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}} #define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}}
/* field-access macros */ /* field-access macros */
#define v_(o) ((o)->u.i.v__) #define v_(o) ((o)->u.i.v__)
#define d_(o) ((o)->u.d__) #define d_(o) ((o)->u.d__)
#define tt_(o) ((o)->u.i.tt__) #define tt_(o) ((o)->u.i.tt__)
#else /* }{ */ #else /* }{ */
/* big endian */ /* big endian */
#define TValuefields \ #define TValuefields \
union { struct { int tt__; Value v__; } i; double d__; } u union { struct { int tt__; Value v__; } i; double d__; } u
#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}} #define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}}
/* field-access macros */ /* field-access macros */
#define v_(o) ((o)->u.i.v__) #define v_(o) ((o)->u.i.v__)
#define d_(o) ((o)->u.d__) #define d_(o) ((o)->u.d__)
#define tt_(o) ((o)->u.i.tt__) #define tt_(o) ((o)->u.i.tt__)
#endif /* } */ #endif /* } */
#endif /* } */ #endif /* } */
/* correspondence with standard representation */ /* correspondence with standard representation */
#undef val_ #undef val_
#define val_(o) v_(o) #define val_(o) v_(o)
#undef num_ #undef num_
#define num_(o) d_(o) #define num_(o) d_(o)
#undef numfield #undef numfield
#define numfield /* no such field; numbers are the entire struct */ #define numfield /* no such field; numbers are the entire struct */
/* basic check to distinguish numbers from non-numbers */ /* basic check to distinguish numbers from non-numbers */
#undef ttisnumber #undef ttisnumber
#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK) #define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK)
#define tag2tt(t) (NNMARK | (t)) #define tag2tt(t) (NNMARK | (t))
#undef rttype #undef rttype
#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff) #define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
#undef settt_ #undef settt_
#define settt_(o,t) (tt_(o) = tag2tt(t)) #define settt_(o,t) (tt_(o) = tag2tt(t))
#undef setnvalue #undef setnvalue
#define setnvalue(obj,x) \ #define setnvalue(obj,x) \
{ TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); } { TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); }
#undef setobj #undef setobj
#define setobj(L,obj1,obj2) \ #define setobj(L,obj1,obj2) \
{ const TValue *o2_=(obj2); TValue *o1_=(obj1); \ { const TValue *o2_=(obj2); TValue *o1_=(obj1); \
o1_->u = o2_->u; \ o1_->u = o2_->u; \
checkliveness(G(L),o1_); } checkliveness(G(L),o1_); }
/* /*
@ -362,16 +362,16 @@ typedef struct lua_TValue TValue;
#undef checktag #undef checktag
#undef checktype #undef checktype
#define checktag(o,t) (tt_(o) == tag2tt(t)) #define checktag(o,t) (tt_(o) == tag2tt(t))
#define checktype(o,t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS)) #define checktype(o,t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS))
#undef ttisequal #undef ttisequal
#define ttisequal(o1,o2) \ #define ttisequal(o1,o2) \
(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2))) (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
#undef luai_checknum #undef luai_checknum
#define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; } #define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; }
#endif #endif
/* }====================================================== */ /* }====================================================== */
@ -419,7 +419,7 @@ typedef union TString {
/* get the actual string (array of bytes) from a TString */ /* get the actual string (array of bytes) from a TString */
#define getstr(ts) cast(const char *, (ts) + 1) #define getstr(ts) cast(const char *, (ts) + 1)
/* get the actual string (array of bytes) from a Lua value */ /* get the actual string (array of bytes) from a Lua value */
#define svalue(o) getstr(rawtsvalue(o)) #define svalue(o) getstr(rawtsvalue(o))
@ -511,7 +511,7 @@ typedef struct UpVal {
*/ */
#define ClosureHeader \ #define ClosureHeader \
CommonHeader; lu_byte nupvalues; GCObject *gclist CommonHeader; lu_byte nupvalues; GCObject *gclist
typedef struct CClosure { typedef struct CClosure {
ClosureHeader; ClosureHeader;
@ -533,9 +533,9 @@ typedef union Closure {
} Closure; } Closure;
#define isLfunction(o) ttisLclosure(o) #define isLfunction(o) ttisLclosure(o)
#define getproto(o) (clLvalue(o)->p) #define getproto(o) (clLvalue(o)->p)
/* /*
@ -575,17 +575,17 @@ typedef struct Table {
** `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) \ #define lmod(s,size) \
(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1))))) (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
#define twoto(x) (1<<(x)) #define twoto(x) (1<<(x))
#define sizenode(t) (twoto((t)->lsizenode)) #define sizenode(t) (twoto((t)->lsizenode))
/* /*
** (address of) a fixed nil value ** (address of) a fixed nil value
*/ */
#define luaO_nilobject (&luaO_nilobject_) #define luaO_nilobject (&luaO_nilobject_)
LUAI_DDEC const TValue luaO_nilobject_; LUAI_DDEC const TValue luaO_nilobject_;

82
liblua/lopcodes.c
View file

@ -62,46 +62,46 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m)) #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = { LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
/* T A B C mode opcode */ /* T A B C mode opcode */
opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */ opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */
,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */ ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */
,opmode(0, 1, OpArgN, OpArgN, iABx) /* OP_LOADKX */ ,opmode(0, 1, OpArgN, OpArgN, iABx) /* OP_LOADKX */
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */ ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_LOADNIL */ ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_LOADNIL */
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */ ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */
,opmode(0, 1, OpArgU, OpArgK, iABC) /* OP_GETTABUP */ ,opmode(0, 1, OpArgU, OpArgK, iABC) /* OP_GETTABUP */
,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */ ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */
,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABUP */ ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABUP */
,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */ ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */
,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */ ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */ ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */
,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */ ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */
,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */ ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */
,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */ ,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */ ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */ ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */ ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */
,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TEST */ ,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TEST */
,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */ ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */ ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */ ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */
,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */ ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */
,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */ ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */
,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */ ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */
,opmode(0, 0, OpArgN, OpArgU, iABC) /* OP_TFORCALL */ ,opmode(0, 0, OpArgN, OpArgU, iABC) /* OP_TFORCALL */
,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_TFORLOOP */ ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_TFORLOOP */
,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */ ,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */
,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */ ,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */ ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */
,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */ ,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */
}; };

214
liblua/lopcodes.h
View file

@ -14,12 +14,12 @@
We assume that instructions are unsigned numbers. We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits. All instructions have an opcode in the first 6 bits.
Instructions can have the following fields: Instructions can have the following fields:
`A' : 8 bits `A' : 8 bits
`B' : 9 bits `B' : 9 bits
`C' : 9 bits `C' : 9 bits
'Ax' : 26 bits ('A', 'B', and 'C' together) 'Ax' : 26 bits ('A', 'B', and 'C' together)
`Bx' : 18 bits (`B' and `C' together) `Bx' : 18 bits (`B' and `C' together)
`sBx' : signed Bx `sBx' : signed Bx
A signed argument is represented in excess K; that is, the number A signed argument is represented in excess K; that is, the number
value is the unsigned value minus K. K is exactly the maximum value value is the unsigned value minus K. K is exactly the maximum value
@ -35,20 +35,20 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */
/* /*
** size and position of opcode arguments. ** size and position of opcode arguments.
*/ */
#define SIZE_C 9 #define SIZE_C 9
#define SIZE_B 9 #define SIZE_B 9
#define SIZE_Bx (SIZE_C + SIZE_B) #define SIZE_Bx (SIZE_C + SIZE_B)
#define SIZE_A 8 #define SIZE_A 8
#define SIZE_Ax (SIZE_C + SIZE_B + SIZE_A) #define SIZE_Ax (SIZE_C + SIZE_B + SIZE_A)
#define SIZE_OP 6 #define SIZE_OP 6
#define POS_OP 0 #define POS_OP 0
#define POS_A (POS_OP + SIZE_OP) #define POS_A (POS_OP + SIZE_OP)
#define POS_C (POS_A + SIZE_A) #define POS_C (POS_A + SIZE_A)
#define POS_B (POS_C + SIZE_C) #define POS_B (POS_C + SIZE_C)
#define POS_Bx POS_C #define POS_Bx POS_C
#define POS_Ax POS_A #define POS_Ax POS_A
/* /*
@ -57,17 +57,17 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */
** so they must fit in LUAI_BITSINT-1 bits (-1 for sign) ** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
*/ */
#if SIZE_Bx < LUAI_BITSINT-1 #if SIZE_Bx < LUAI_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
#define MAXARG_Bx MAX_INT #define MAXARG_Bx MAX_INT
#define MAXARG_sBx MAX_INT #define MAXARG_sBx MAX_INT
#endif #endif
#if SIZE_Ax < LUAI_BITSINT-1 #if SIZE_Ax < LUAI_BITSINT-1
#define MAXARG_Ax ((1<<SIZE_Ax)-1) #define MAXARG_Ax ((1<<SIZE_Ax)-1)
#else #else
#define MAXARG_Ax MAX_INT #define MAXARG_Ax MAX_INT
#endif #endif
@ -77,53 +77,53 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */
/* creates a mask with `n' 1 bits at position `p' */ /* creates a mask with `n' 1 bits at position `p' */
#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) #define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p))
/* creates a mask with `n' 0 bits at position `p' */ /* creates a mask with `n' 0 bits at position `p' */
#define MASK0(n,p) (~MASK1(n,p)) #define MASK0(n,p) (~MASK1(n,p))
/* /*
** the following macros help to manipulate instructions ** the following macros help to manipulate instructions
*/ */
#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) #define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ #define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP)))) ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
#define getarg(i,pos,size) (cast(int, ((i)>>pos) & MASK1(size,0))) #define getarg(i,pos,size) (cast(int, ((i)>>pos) & MASK1(size,0)))
#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ #define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \
((cast(Instruction, v)<<pos)&MASK1(size,pos)))) ((cast(Instruction, v)<<pos)&MASK1(size,pos))))
#define GETARG_A(i) getarg(i, POS_A, SIZE_A) #define GETARG_A(i) getarg(i, POS_A, SIZE_A)
#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) #define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A)
#define GETARG_B(i) getarg(i, POS_B, SIZE_B) #define GETARG_B(i) getarg(i, POS_B, SIZE_B)
#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B) #define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B)
#define GETARG_C(i) getarg(i, POS_C, SIZE_C) #define GETARG_C(i) getarg(i, POS_C, SIZE_C)
#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) #define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C)
#define GETARG_Bx(i) getarg(i, POS_Bx, SIZE_Bx) #define GETARG_Bx(i) getarg(i, POS_Bx, SIZE_Bx)
#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx) #define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx)
#define GETARG_Ax(i) getarg(i, POS_Ax, SIZE_Ax) #define GETARG_Ax(i) getarg(i, POS_Ax, SIZE_Ax)
#define SETARG_Ax(i,v) setarg(i, v, POS_Ax, SIZE_Ax) #define SETARG_Ax(i,v) setarg(i, v, POS_Ax, SIZE_Ax)
#define GETARG_sBx(i) (GETARG_Bx(i)-MAXARG_sBx) #define GETARG_sBx(i) (GETARG_Bx(i)-MAXARG_sBx)
#define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx)) #define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
#define CREATE_ABC(o,a,b,c) ((cast(Instruction, o)<<POS_OP) \ #define CREATE_ABC(o,a,b,c) ((cast(Instruction, o)<<POS_OP) \
| (cast(Instruction, a)<<POS_A) \ | (cast(Instruction, a)<<POS_A) \
| (cast(Instruction, b)<<POS_B) \ | (cast(Instruction, b)<<POS_B) \
| (cast(Instruction, c)<<POS_C)) | (cast(Instruction, c)<<POS_C))
#define CREATE_ABx(o,a,bc) ((cast(Instruction, o)<<POS_OP) \ #define CREATE_ABx(o,a,bc) ((cast(Instruction, o)<<POS_OP) \
| (cast(Instruction, a)<<POS_A) \ | (cast(Instruction, a)<<POS_A) \
| (cast(Instruction, bc)<<POS_Bx)) | (cast(Instruction, bc)<<POS_Bx))
#define CREATE_Ax(o,a) ((cast(Instruction, o)<<POS_OP) \ #define CREATE_Ax(o,a) ((cast(Instruction, o)<<POS_OP) \
| (cast(Instruction, a)<<POS_Ax)) | (cast(Instruction, a)<<POS_Ax))
/* /*
@ -131,24 +131,24 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */
*/ */
/* this bit 1 means constant (0 means register) */ /* this bit 1 means constant (0 means register) */
#define BITRK (1 << (SIZE_B - 1)) #define BITRK (1 << (SIZE_B - 1))
/* test whether value is a constant */ /* test whether value is a constant */
#define ISK(x) ((x) & BITRK) #define ISK(x) ((x) & BITRK)
/* gets the index of the constant */ /* gets the index of the constant */
#define INDEXK(r) ((int)(r) & ~BITRK) #define INDEXK(r) ((int)(r) & ~BITRK)
#define MAXINDEXRK (BITRK - 1) #define MAXINDEXRK (BITRK - 1)
/* code a constant index as a RK value */ /* code a constant index as a RK value */
#define RKASK(x) ((x) | BITRK) #define RKASK(x) ((x) | BITRK)
/* /*
** invalid register that fits in 8 bits ** invalid register that fits in 8 bits
*/ */
#define NO_REG MAXARG_A #define NO_REG MAXARG_A
/* /*
@ -164,68 +164,68 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */
typedef enum { typedef enum {
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
name args description name args description
------------------------------------------------------------------------*/ ------------------------------------------------------------------------*/
OP_MOVE,/* A B R(A) := R(B) */ OP_MOVE,/* A B R(A) := R(B) */
OP_LOADK,/* A Bx R(A) := Kst(Bx) */ OP_LOADK,/* A Bx R(A) := Kst(Bx) */
OP_LOADKX,/* A R(A) := Kst(extra arg) */ OP_LOADKX,/* A R(A) := Kst(extra arg) */
OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */ OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */
OP_LOADNIL,/* A B R(A), R(A+1), ..., R(A+B) := nil */ OP_LOADNIL,/* A B R(A), R(A+1), ..., R(A+B) := nil */
OP_GETUPVAL,/* A B R(A) := UpValue[B] */ OP_GETUPVAL,/* A B R(A) := UpValue[B] */
OP_GETTABUP,/* A B C R(A) := UpValue[B][RK(C)] */ OP_GETTABUP,/* A B C R(A) := UpValue[B][RK(C)] */
OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)] */ OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)] */
OP_SETTABUP,/* A B C UpValue[A][RK(B)] := RK(C) */ OP_SETTABUP,/* A B C UpValue[A][RK(B)] := RK(C) */
OP_SETUPVAL,/* A B UpValue[B] := R(A) */ OP_SETUPVAL,/* A B UpValue[B] := R(A) */
OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */ OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */
OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */ OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */
OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */ OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */
OP_ADD,/* A B C R(A) := RK(B) + RK(C) */ OP_ADD,/* A B C R(A) := RK(B) + RK(C) */
OP_SUB,/* A B C R(A) := RK(B) - RK(C) */ OP_SUB,/* A B C R(A) := RK(B) - RK(C) */
OP_MUL,/* A B C R(A) := RK(B) * RK(C) */ OP_MUL,/* A B C R(A) := RK(B) * RK(C) */
OP_DIV,/* A B C R(A) := RK(B) / RK(C) */ OP_DIV,/* A B C R(A) := RK(B) / RK(C) */
OP_MOD,/* A B C R(A) := RK(B) % RK(C) */ OP_MOD,/* A B C R(A) := RK(B) % RK(C) */
OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */ OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */
OP_UNM,/* A B R(A) := -R(B) */ OP_UNM,/* A B R(A) := -R(B) */
OP_NOT,/* A B R(A) := not R(B) */ OP_NOT,/* A B R(A) := not R(B) */
OP_LEN,/* A B R(A) := length of R(B) */ OP_LEN,/* A B R(A) := length of R(B) */
OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */ OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A) + 1 */ OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A) + 1 */
OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */ OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */
OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */ OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */
OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */ OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
OP_TEST,/* A C if not (R(A) <=> C) then pc++ */ OP_TEST,/* A C if not (R(A) <=> C) then pc++ */
OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */ OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */ OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */ OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
OP_FORLOOP,/* A sBx R(A)+=R(A+2); OP_FORLOOP,/* A sBx R(A)+=R(A+2);
if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/ if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */ OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */
OP_TFORCALL,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); */ OP_TFORCALL,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); */
OP_TFORLOOP,/* A sBx if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/ OP_TFORLOOP,/* A sBx if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */ OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx]) */ OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx]) */
OP_VARARG,/* A B R(A), R(A+1), ..., R(A+B-2) = vararg */ OP_VARARG,/* A B R(A), R(A+1), ..., R(A+B-2) = vararg */
OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */ OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */
} OpCode; } OpCode;
#define NUM_OPCODES (cast(int, OP_EXTRAARG) + 1) #define NUM_OPCODES (cast(int, OP_EXTRAARG) + 1)
@ -271,18 +271,18 @@ enum OpArgMask {
LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES]; LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];
#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3)) #define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3))
#define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3)) #define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3)) #define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
#define testAMode(m) (luaP_opmodes[m] & (1 << 6)) #define testAMode(m) (luaP_opmodes[m] & (1 << 6))
#define testTMode(m) (luaP_opmodes[m] & (1 << 7)) #define testTMode(m) (luaP_opmodes[m] & (1 << 7))
LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */ LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */
/* number of list items to accumulate before a SETLIST instruction */ /* number of list items to accumulate before a SETLIST instruction */
#define LFIELDS_PER_FLUSH 50 #define LFIELDS_PER_FLUSH 50
#endif #endif

22
liblua/loslib.c
View file

@ -26,12 +26,12 @@
#if !defined(LUA_STRFTIMEOPTIONS) #if !defined(LUA_STRFTIMEOPTIONS)
#if !defined(LUA_USE_POSIX) #if !defined(LUA_USE_POSIX)
#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" } #define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" }
#else #else
#define LUA_STRFTIMEOPTIONS \ #define LUA_STRFTIMEOPTIONS \
{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \ { "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \
"", "E", "cCxXyY", \ "", "E", "cCxXyY", \
"O", "deHImMSuUVwWy" } "O", "deHImMSuUVwWy" }
#endif #endif
#endif #endif
@ -44,7 +44,7 @@
*/ */
#if defined(LUA_USE_MKSTEMP) #if defined(LUA_USE_MKSTEMP)
#include <unistd.h> #include <unistd.h>
#define LUA_TMPNAMBUFSIZE 32 #define LUA_TMPNAMBUFSIZE 32
#define lua_tmpnam(b,e) { \ #define lua_tmpnam(b,e) { \
strcpy(b, "/tmp/lua_XXXXXX"); \ strcpy(b, "/tmp/lua_XXXXXX"); \
e = mkstemp(b); \ e = mkstemp(b); \
@ -53,8 +53,8 @@
#elif !defined(lua_tmpnam) #elif !defined(lua_tmpnam)
#define LUA_TMPNAMBUFSIZE L_tmpnam #define LUA_TMPNAMBUFSIZE L_tmpnam
#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } #define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }
#endif #endif
@ -65,13 +65,13 @@
*/ */
#if defined(LUA_USE_GMTIME_R) #if defined(LUA_USE_GMTIME_R)
#define l_gmtime(t,r) gmtime_r(t,r) #define l_gmtime(t,r) gmtime_r(t,r)
#define l_localtime(t,r) localtime_r(t,r) #define l_localtime(t,r) localtime_r(t,r)
#elif !defined(l_gmtime) #elif !defined(l_gmtime)
#define l_gmtime(t,r) ((void)r, gmtime(t)) #define l_gmtime(t,r) ((void)r, gmtime(t))
#define l_localtime(t,r) ((void)r, localtime(t)) #define l_localtime(t,r) ((void)r, localtime(t))
#endif #endif

12
liblua/lparser.c
View file

@ -29,10 +29,10 @@
/* maximum number of local variables per function (must be smaller /* maximum number of local variables per function (must be smaller
than 250, due to the bytecode format) */ than 250, due to the bytecode format) */
#define MAXVARS 200 #define MAXVARS 200
#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) #define hasmultret(k) ((k) == VCALL || (k) == VVARARG)
@ -119,7 +119,7 @@ static void checknext (LexState *ls, int c) {
} }
#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } #define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); }
@ -192,7 +192,7 @@ static void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) {
} }
#define new_localvarliteral(ls,v) \ #define new_localvarliteral(ls,v) \
new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1) new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1)
static LocVar *getlocvar (FuncState *fs, int i) { static LocVar *getlocvar (FuncState *fs, int i) {
@ -334,7 +334,7 @@ static void enterlevel (LexState *ls) {
} }
#define leavelevel(ls) ((ls)->L->nCcalls--) #define leavelevel(ls) ((ls)->L->nCcalls--)
static void closegoto (LexState *ls, int g, Labeldesc *label) { static void closegoto (LexState *ls, int g, Labeldesc *label) {
@ -1027,7 +1027,7 @@ static const struct {
{2, 2}, {1, 1} /* and, or */ {2, 2}, {1, 1} /* and, or */
}; };
#define UNARY_PRIORITY 8 /* priority for unary operators */ #define UNARY_PRIORITY 8 /* priority for unary operators */
/* /*

24
liblua/lparser.h
View file

@ -17,25 +17,25 @@
*/ */
typedef enum { typedef enum {
VVOID, /* no value */ VVOID, /* no value */
VNIL, VNIL,
VTRUE, VTRUE,
VFALSE, VFALSE,
VK, /* info = index of constant in `k' */ VK, /* info = index of constant in `k' */
VKNUM, /* nval = numerical value */ VKNUM, /* nval = numerical value */
VNONRELOC, /* info = result register */ VNONRELOC, /* info = result register */
VLOCAL, /* info = local register */ VLOCAL, /* info = local register */
VUPVAL, /* info = index of upvalue in 'upvalues' */ VUPVAL, /* info = index of upvalue in 'upvalues' */
VINDEXED, /* t = table register/upvalue; idx = index R/K */ VINDEXED, /* t = table register/upvalue; idx = index R/K */
VJMP, /* info = instruction pc */ VJMP, /* info = instruction pc */
VRELOCABLE, /* info = instruction pc */ VRELOCABLE, /* info = instruction pc */
VCALL, /* info = instruction pc */ VCALL, /* info = instruction pc */
VVARARG /* info = instruction pc */ VVARARG /* info = instruction pc */
} expkind; } expkind;
#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXED) #define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXED)
#define vkisinreg(k) ((k) == VNONRELOC || (k) == VLOCAL) #define vkisinreg(k) ((k) == VNONRELOC || (k) == VLOCAL)
typedef struct expdesc { typedef struct expdesc {
expkind k; expkind k;

12
liblua/lstate.c
View file

@ -27,19 +27,19 @@
#if !defined(LUAI_GCPAUSE) #if !defined(LUAI_GCPAUSE)
#define LUAI_GCPAUSE 200 /* 200% */ #define LUAI_GCPAUSE 200 /* 200% */
#endif #endif
#if !defined(LUAI_GCMAJOR) #if !defined(LUAI_GCMAJOR)
#define LUAI_GCMAJOR 200 /* 200% */ #define LUAI_GCMAJOR 200 /* 200% */
#endif #endif
#if !defined(LUAI_GCMUL) #if !defined(LUAI_GCMUL)
#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ #define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */
#endif #endif
#define MEMERRMSG "not enough memory" #define MEMERRMSG "not enough memory"
/* /*
@ -48,7 +48,7 @@
*/ */
#if !defined(luai_makeseed) #if !defined(luai_makeseed)
#include <time.h> #include <time.h>
#define luai_makeseed() cast(unsigned int, time(NULL)) #define luai_makeseed() cast(unsigned int, time(NULL))
#endif #endif
@ -74,7 +74,7 @@ typedef struct LG {
#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) #define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
/* /*

56
liblua/lstate.h
View file

@ -51,9 +51,9 @@ struct lua_longjmp; /* defined in ldo.c */
/* kinds of Garbage Collection */ /* kinds of Garbage Collection */
#define KGC_NORMAL 0 #define KGC_NORMAL 0
#define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */ #define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */
#define KGC_GEN 2 /* generational collection */ #define KGC_GEN 2 /* generational collection */
typedef struct stringtable { typedef struct stringtable {
@ -68,7 +68,7 @@ typedef struct stringtable {
*/ */
typedef struct CallInfo { typedef struct CallInfo {
StkId func; /* function index in the stack */ StkId func; /* function index in the stack */
StkId top; /* top for this function */ StkId top; /* top for this function */
struct CallInfo *previous, *next; /* dynamic call link */ struct CallInfo *previous, *next; /* dynamic call link */
short nresults; /* expected number of results from this function */ short nresults; /* expected number of results from this function */
lu_byte callstatus; lu_byte callstatus;
@ -92,18 +92,18 @@ typedef struct CallInfo {
/* /*
** Bits in CallInfo status ** Bits in CallInfo status
*/ */
#define CIST_LUA (1<<0) /* call is running a Lua function */ #define CIST_LUA (1<<0) /* call is running a Lua function */
#define CIST_HOOKED (1<<1) /* call is running a debug hook */ #define CIST_HOOKED (1<<1) /* call is running a debug hook */
#define CIST_REENTRY (1<<2) /* call is running on same invocation of #define CIST_REENTRY (1<<2) /* call is running on same invocation of
luaV_execute of previous call */ luaV_execute of previous call */
#define CIST_YIELDED (1<<3) /* call reentered after suspension */ #define CIST_YIELDED (1<<3) /* call reentered after suspension */
#define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ #define CIST_YPCALL (1<<4) /* call is a yieldable protected call */
#define CIST_STAT (1<<5) /* call has an error status (pcall) */ #define CIST_STAT (1<<5) /* call has an error status (pcall) */
#define CIST_TAIL (1<<6) /* call was tail called */ #define CIST_TAIL (1<<6) /* call was tail called */
#define CIST_HOOKYIELD (1<<7) /* last hook called yielded */ #define CIST_HOOKYIELD (1<<7) /* last hook called yielded */
#define isLua(ci) ((ci)->callstatus & CIST_LUA) #define isLua(ci) ((ci)->callstatus & CIST_LUA)
/* /*
@ -176,7 +176,7 @@ struct lua_State {
}; };
#define G(L) (L->l_G) #define G(L) (L->l_G)
/* /*
@ -194,29 +194,29 @@ union GCObject {
}; };
#define gch(o) (&(o)->gch) #define gch(o) (&(o)->gch)
/* macros to convert a GCObject into a specific value */ /* macros to convert a GCObject into a specific value */
#define rawgco2ts(o) \ #define rawgco2ts(o) \
check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts)) check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts))
#define gco2ts(o) (&rawgco2ts(o)->tsv) #define gco2ts(o) (&rawgco2ts(o)->tsv)
#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) #define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
#define gco2u(o) (&rawgco2u(o)->uv) #define gco2u(o) (&rawgco2u(o)->uv)
#define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l)) #define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l))
#define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c)) #define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c))
#define gco2cl(o) \ #define gco2cl(o) \
check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl)) check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
#define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) #define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) #define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) #define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) #define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
/* macro to convert any Lua object into a GCObject */ /* macro to convert any Lua object into a GCObject */
#define obj2gco(v) (cast(GCObject *, (v))) #define obj2gco(v) (cast(GCObject *, (v)))
/* actual number of total bytes allocated */ /* actual number of total bytes allocated */
#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt) #define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt)
LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);

2
liblua/lstring.c
View file

@ -23,7 +23,7 @@
** compute its hash ** compute its hash
*/ */
#if !defined(LUAI_HASHLIMIT) #if !defined(LUAI_HASHLIMIT)
#define LUAI_HASHLIMIT 5 #define LUAI_HASHLIMIT 5
#endif #endif

12
liblua/lstring.h
View file

@ -12,26 +12,26 @@
#include "lstate.h" #include "lstate.h"
#define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) #define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char))
#define sizeudata(u) (sizeof(union Udata)+(u)->len) #define sizeudata(u) (sizeof(union Udata)+(u)->len)
#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
(sizeof(s)/sizeof(char))-1)) (sizeof(s)/sizeof(char))-1))
#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) #define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT)
/* /*
** test whether a string is a reserved word ** test whether a string is a reserved word
*/ */
#define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0) #define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0)
/* /*
** equality for short strings, which are always internalized ** equality for short strings, which are always internalized
*/ */
#define eqshrstr(a,b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b)) #define eqshrstr(a,b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b))
LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);

38
liblua/lstrlib.c
View file

@ -25,12 +25,12 @@
** pattern-matching. This limit is arbitrary. ** pattern-matching. This limit is arbitrary.
*/ */
#if !defined(LUA_MAXCAPTURES) #if !defined(LUA_MAXCAPTURES)
#define LUA_MAXCAPTURES 32 #define LUA_MAXCAPTURES 32
#endif #endif
/* macro to `unsign' a character */ /* macro to `unsign' a character */
#define uchar(c) ((unsigned char)(c)) #define uchar(c) ((unsigned char)(c))
@ -103,7 +103,7 @@ static int str_upper (lua_State *L) {
/* reasonable limit to avoid arithmetic overflow */ /* reasonable limit to avoid arithmetic overflow */
#define MAXSIZE ((~(size_t)0) >> 1) #define MAXSIZE ((~(size_t)0) >> 1)
static int str_rep (lua_State *L) { static int str_rep (lua_State *L) {
size_t l, lsep; size_t l, lsep;
@ -191,8 +191,8 @@ static int str_dump (lua_State *L) {
*/ */
#define CAP_UNFINISHED (-1) #define CAP_UNFINISHED (-1)
#define CAP_POSITION (-2) #define CAP_POSITION (-2)
typedef struct MatchState { typedef struct MatchState {
@ -215,12 +215,12 @@ static const char *match (MatchState *ms, const char *s, const char *p);
/* maximum recursion depth for 'match' */ /* maximum recursion depth for 'match' */
#if !defined(MAXCCALLS) #if !defined(MAXCCALLS)
#define MAXCCALLS 200 #define MAXCCALLS 200
#endif #endif
#define L_ESC '%' #define L_ESC '%'
#define SPECIALS "^$*+?.([%-" #define SPECIALS "^$*+?.([%-"
static int check_capture (MatchState *ms, int l) { static int check_capture (MatchState *ms, int l) {
@ -791,19 +791,19 @@ static int str_gsub (lua_State *L) {
** 'string.format'; LUA_INTFRM_T is the integer type corresponding to ** 'string.format'; LUA_INTFRM_T is the integer type corresponding to
** the previous length ** the previous length
*/ */
#if !defined(LUA_INTFRMLEN) /* { */ #if !defined(LUA_INTFRMLEN) /* { */
#if defined(LUA_USE_LONGLONG) #if defined(LUA_USE_LONGLONG)
#define LUA_INTFRMLEN "ll" #define LUA_INTFRMLEN "ll"
#define LUA_INTFRM_T long long #define LUA_INTFRM_T long long
#else #else
#define LUA_INTFRMLEN "l" #define LUA_INTFRMLEN "l"
#define LUA_INTFRM_T long #define LUA_INTFRM_T long
#endif #endif
#endif /* } */ #endif /* } */
/* /*
@ -813,21 +813,21 @@ static int str_gsub (lua_State *L) {
*/ */
#if !defined(LUA_FLTFRMLEN) #if !defined(LUA_FLTFRMLEN)
#define LUA_FLTFRMLEN "" #define LUA_FLTFRMLEN ""
#define LUA_FLTFRM_T double #define LUA_FLTFRM_T double
#endif #endif
/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ /* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
#define MAX_ITEM 512 #define MAX_ITEM 512
/* valid flags in a format specification */ /* valid flags in a format specification */
#define FLAGS "-+ #0" #define FLAGS "-+ #0"
/* /*
** maximum size of each format specification (such as '%-099.99d') ** maximum size of each format specification (such as '%-099.99d')
** (+10 accounts for %99.99x plus margin of error) ** (+10 accounts for %99.99x plus margin of error)
*/ */
#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10) #define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
static void addquoted (lua_State *L, luaL_Buffer *b, int arg) { static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {

20
liblua/ltable.c
View file

@ -40,33 +40,33 @@
** max size of array part is 2^MAXBITS ** max size of array part is 2^MAXBITS
*/ */
#if LUAI_BITSINT >= 32 #if LUAI_BITSINT >= 32
#define MAXBITS 30 #define MAXBITS 30
#else #else
#define MAXBITS (LUAI_BITSINT-2) #define MAXBITS (LUAI_BITSINT-2)
#endif #endif
#define MAXASIZE (1 << MAXBITS) #define MAXASIZE (1 << MAXBITS)
#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) #define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t))))
#define hashstr(t,str) hashpow2(t, (str)->tsv.hash) #define hashstr(t,str) hashpow2(t, (str)->tsv.hash)
#define hashboolean(t,p) hashpow2(t, p) #define hashboolean(t,p) hashpow2(t, p)
/* /*
** for some types, it is better to avoid modulus by power of 2, as ** for some types, it is better to avoid modulus by power of 2, as
** they tend to have many 2 factors. ** they tend to have many 2 factors.
*/ */
#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) #define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1))))
#define hashpointer(t,p) hashmod(t, IntPoint(p)) #define hashpointer(t,p) hashmod(t, IntPoint(p))
#define dummynode (&dummynode_) #define dummynode (&dummynode_)
#define isdummy(n) ((n) == dummynode) #define isdummy(n) ((n) == dummynode)
static const Node dummynode_ = { static const Node dummynode_ = {
{NILCONSTANT}, /* value */ {NILCONSTANT}, /* value */

10
liblua/ltable.h
View file

@ -10,12 +10,12 @@
#include "lobject.h" #include "lobject.h"
#define gnode(t,i) (&(t)->node[i]) #define gnode(t,i) (&(t)->node[i])
#define gkey(n) (&(n)->i_key.tvk) #define gkey(n) (&(n)->i_key.tvk)
#define gval(n) (&(n)->i_val) #define gval(n) (&(n)->i_val)
#define gnext(n) ((n)->i_key.nk.next) #define gnext(n) ((n)->i_key.nk.next)
#define invalidateTMcache(t) ((t)->flags = 0) #define invalidateTMcache(t) ((t)->flags = 0)
LUAI_FUNC const TValue *luaH_getint (Table *t, int key); LUAI_FUNC const TValue *luaH_getint (Table *t, int key);

2
liblua/ltablib.c
View file

@ -16,7 +16,7 @@
#include "lualib.h" #include "lualib.h"
#define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n)) #define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n))

8
liblua/ltm.h
View file

@ -33,7 +33,7 @@ typedef enum {
TM_LE, TM_LE,
TM_CONCAT, TM_CONCAT,
TM_CALL, TM_CALL,
TM_N /* number of elements in the enum */ TM_N /* number of elements in the enum */
} TMS; } TMS;
@ -41,10 +41,10 @@ typedef enum {
#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
#define fasttm(l,et,e) gfasttm(G(l), et, e) #define fasttm(l,et,e) gfasttm(G(l), et, e)
#define ttypename(x) luaT_typenames_[(x) + 1] #define ttypename(x) luaT_typenames_[(x) + 1]
#define objtypename(x) ttypename(ttypenv(x)) #define objtypename(x) ttypename(ttypenv(x))
LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS]; LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];

42
liblua/lua.c
View file

@ -19,24 +19,24 @@
#if !defined(LUA_PROMPT) #if !defined(LUA_PROMPT)
#define LUA_PROMPT "> " #define LUA_PROMPT "> "
#define LUA_PROMPT2 ">> " #define LUA_PROMPT2 ">> "
#endif #endif
#if !defined(LUA_PROGNAME) #if !defined(LUA_PROGNAME)
#define LUA_PROGNAME "lua" #define LUA_PROGNAME "lua"
#endif #endif
#if !defined(LUA_MAXINPUT) #if !defined(LUA_MAXINPUT)
#define LUA_MAXINPUT 512 #define LUA_MAXINPUT 512
#endif #endif
#if !defined(LUA_INIT) #if !defined(LUA_INIT)
#define LUA_INIT "LUA_INIT" #define LUA_INIT "LUA_INIT"
#endif #endif
#define LUA_INITVERSION \ #define LUA_INITVERSION \
LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
/* /*
@ -45,13 +45,13 @@
*/ */
#if defined(LUA_USE_ISATTY) #if defined(LUA_USE_ISATTY)
#include <unistd.h> #include <unistd.h>
#define lua_stdin_is_tty() isatty(0) #define lua_stdin_is_tty() isatty(0)
#elif defined(LUA_WIN) #elif defined(LUA_WIN)
#include <io.h> #include <io.h>
#include <stdio.h> #include <stdio.h>
#define lua_stdin_is_tty() _isatty(_fileno(stdin)) #define lua_stdin_is_tty() _isatty(_fileno(stdin))
#else #else
#define lua_stdin_is_tty() 1 /* assume stdin is a tty */ #define lua_stdin_is_tty() 1 /* assume stdin is a tty */
#endif #endif
@ -66,19 +66,19 @@
#include <stdio.h> #include <stdio.h>
#include <readline/readline.h> #include <readline/readline.h>
#include <readline/history.h> #include <readline/history.h>
#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) #define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)
#define lua_saveline(L,idx) \ #define lua_saveline(L,idx) \
if (lua_rawlen(L,idx) > 0) /* non-empty line? */ \ if (lua_rawlen(L,idx) > 0) /* non-empty line? */ \
add_history(lua_tostring(L, idx)); /* add it to history */ add_history(lua_tostring(L, idx)); /* add it to history */
#define lua_freeline(L,b) ((void)L, free(b)) #define lua_freeline(L,b) ((void)L, free(b))
#elif !defined(lua_readline) #elif !defined(lua_readline)
#define lua_readline(L,b,p) \ #define lua_readline(L,b,p) \
((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \
fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */
#define lua_saveline(L,idx) { (void)L; (void)idx; } #define lua_saveline(L,idx) { (void)L; (void)idx; }
#define lua_freeline(L,b) { (void)L; (void)b; } #define lua_freeline(L,b) { (void)L; (void)b; }
#endif #endif
@ -241,8 +241,8 @@ static const char *get_prompt (lua_State *L, int firstline) {
} }
/* mark in error messages for incomplete statements */ /* mark in error messages for incomplete statements */
#define EOFMARK "<eof>" #define EOFMARK "<eof>"
#define marklen (sizeof(EOFMARK)/sizeof(char) - 1) #define marklen (sizeof(EOFMARK)/sizeof(char) - 1)
static int incomplete (lua_State *L, int status) { static int incomplete (lua_State *L, int status) {
if (status == LUA_ERRSYNTAX) { if (status == LUA_ERRSYNTAX) {
@ -342,16 +342,16 @@ static int handle_script (lua_State *L, char **argv, int n) {
/* check that argument has no extra characters at the end */ /* check that argument has no extra characters at the end */
#define noextrachars(x) {if ((x)[2] != '\0') return -1;} #define noextrachars(x) {if ((x)[2] != '\0') return -1;}
/* indices of various argument indicators in array args */ /* indices of various argument indicators in array args */
#define has_i 0 /* -i */ #define has_i 0 /* -i */
#define has_v 1 /* -v */ #define has_v 1 /* -v */
#define has_e 2 /* -e */ #define has_e 2 /* -e */
#define has_E 3 /* -E */ #define has_E 3 /* -E */
#define num_has 4 /* number of 'has_*' */ #define num_has 4 /* number of 'has_*' */
static int collectargs (char **argv, int *args) { static int collectargs (char **argv, int *args) {

195
liblua/lua.h
View file

@ -16,39 +16,39 @@
#include "luaconf.h" #include "luaconf.h"
#define LUA_VERSION_MAJOR "5" #define LUA_VERSION_MAJOR "5"
#define LUA_VERSION_MINOR "2" #define LUA_VERSION_MINOR "2"
#define LUA_VERSION_NUM 502 #define LUA_VERSION_NUM 502
#define LUA_VERSION_RELEASE "2" #define LUA_VERSION_RELEASE "2"
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR #define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE #define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2013 Lua.org, PUC-Rio" #define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2013 Lua.org, PUC-Rio"
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
/* mark for precompiled code ('<esc>Lua') */ /* mark for precompiled code ('<esc>Lua') */
#define LUA_SIGNATURE "\033Lua" #define LUA_SIGNATURE "\033Lua"
/* option for multiple returns in 'lua_pcall' and 'lua_call' */ /* option for multiple returns in 'lua_pcall' and 'lua_call' */
#define LUA_MULTRET (-1) #define LUA_MULTRET (-1)
/* /*
** pseudo-indices ** pseudo-indices
*/ */
#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX #define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX
#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) #define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
/* thread status */ /* thread status */
#define LUA_OK 0 #define LUA_OK 0
#define LUA_YIELD 1 #define LUA_YIELD 1
#define LUA_ERRRUN 2 #define LUA_ERRRUN 2
#define LUA_ERRSYNTAX 3 #define LUA_ERRSYNTAX 3
#define LUA_ERRMEM 4 #define LUA_ERRMEM 4
#define LUA_ERRGCMM 5 #define LUA_ERRGCMM 5
#define LUA_ERRERR 6 #define LUA_ERRERR 6
typedef struct lua_State lua_State; typedef struct lua_State lua_State;
@ -73,30 +73,30 @@ typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
/* /*
** basic types ** basic types
*/ */
#define LUA_TNONE (-1) #define LUA_TNONE (-1)
#define LUA_TNIL 0 #define LUA_TNIL 0
#define LUA_TBOOLEAN 1 #define LUA_TBOOLEAN 1
#define LUA_TLIGHTUSERDATA 2 #define LUA_TLIGHTUSERDATA 2
#define LUA_TNUMBER 3 #define LUA_TNUMBER 3
#define LUA_TSTRING 4 #define LUA_TSTRING 4
#define LUA_TTABLE 5 #define LUA_TTABLE 5
#define LUA_TFUNCTION 6 #define LUA_TFUNCTION 6
#define LUA_TUSERDATA 7 #define LUA_TUSERDATA 7
#define LUA_TTHREAD 8 #define LUA_TTHREAD 8
#define LUA_NUMTAGS 9 #define LUA_NUMTAGS 9
/* minimum Lua stack available to a C function */ /* minimum Lua stack available to a C function */
#define LUA_MINSTACK 20 #define LUA_MINSTACK 20
/* predefined values in the registry */ /* predefined values in the registry */
#define LUA_RIDX_MAINTHREAD 1 #define LUA_RIDX_MAINTHREAD 1
#define LUA_RIDX_GLOBALS 2 #define LUA_RIDX_GLOBALS 2
#define LUA_RIDX_LAST LUA_RIDX_GLOBALS #define LUA_RIDX_LAST LUA_RIDX_GLOBALS
/* type of numbers in Lua */ /* type of numbers in Lua */
@ -172,7 +172,7 @@ LUA_API int (lua_toboolean) (lua_State *L, int idx);
LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
LUA_API size_t (lua_rawlen) (lua_State *L, int idx); LUA_API size_t (lua_rawlen) (lua_State *L, int idx);
LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
LUA_API void *(lua_touserdata) (lua_State *L, int idx); LUA_API void *(lua_touserdata) (lua_State *L, int idx);
LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
LUA_API const void *(lua_topointer) (lua_State *L, int idx); LUA_API const void *(lua_topointer) (lua_State *L, int idx);
@ -181,19 +181,19 @@ LUA_API const void *(lua_topointer) (lua_State *L, int idx);
** Comparison and arithmetic functions ** Comparison and arithmetic functions
*/ */
#define LUA_OPADD 0 /* ORDER TM */ #define LUA_OPADD 0 /* ORDER TM */
#define LUA_OPSUB 1 #define LUA_OPSUB 1
#define LUA_OPMUL 2 #define LUA_OPMUL 2
#define LUA_OPDIV 3 #define LUA_OPDIV 3
#define LUA_OPMOD 4 #define LUA_OPMOD 4
#define LUA_OPPOW 5 #define LUA_OPPOW 5
#define LUA_OPUNM 6 #define LUA_OPUNM 6
LUA_API void (lua_arith) (lua_State *L, int op); LUA_API void (lua_arith) (lua_State *L, int op);
#define LUA_OPEQ 0 #define LUA_OPEQ 0
#define LUA_OPLT 1 #define LUA_OPLT 1
#define LUA_OPLE 2 #define LUA_OPLE 2
LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);
@ -250,13 +250,13 @@ LUA_API void (lua_setuservalue) (lua_State *L, int idx);
*/ */
LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, int ctx, LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
lua_CFunction k); lua_CFunction k);
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) #define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
LUA_API int (lua_getctx) (lua_State *L, int *ctx); LUA_API int (lua_getctx) (lua_State *L, int *ctx);
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
int ctx, lua_CFunction k); int ctx, lua_CFunction k);
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) #define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
const char *chunkname, const char *chunkname,
@ -270,7 +270,7 @@ LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
*/ */
LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx, LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx,
lua_CFunction k); lua_CFunction k);
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) #define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg);
LUA_API int (lua_status) (lua_State *L); LUA_API int (lua_status) (lua_State *L);
@ -278,18 +278,18 @@ LUA_API int (lua_status) (lua_State *L);
** garbage-collection function and options ** garbage-collection function and options
*/ */
#define LUA_GCSTOP 0 #define LUA_GCSTOP 0
#define LUA_GCRESTART 1 #define LUA_GCRESTART 1
#define LUA_GCCOLLECT 2 #define LUA_GCCOLLECT 2
#define LUA_GCCOUNT 3 #define LUA_GCCOUNT 3
#define LUA_GCCOUNTB 4 #define LUA_GCCOUNTB 4
#define LUA_GCSTEP 5 #define LUA_GCSTEP 5
#define LUA_GCSETPAUSE 6 #define LUA_GCSETPAUSE 6
#define LUA_GCSETSTEPMUL 7 #define LUA_GCSETSTEPMUL 7
#define LUA_GCSETMAJORINC 8 #define LUA_GCSETMAJORINC 8
#define LUA_GCISRUNNING 9 #define LUA_GCISRUNNING 9
#define LUA_GCGEN 10 #define LUA_GCGEN 10
#define LUA_GCINC 11 #define LUA_GCINC 11
LUA_API int (lua_gc) (lua_State *L, int what, int data); LUA_API int (lua_gc) (lua_State *L, int what, int data);
@ -316,34 +316,35 @@ LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
** =============================================================== ** ===============================================================
*/ */
#define lua_tonumber(L,i) lua_tonumberx(L,i,NULL) #define lua_tonumber(L,i) lua_tonumberx(L,i,NULL)
#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL) #define lua_tointeger(L,i) lua_tointegerx(L,i,NULL)
#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL) #define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL)
#define lua_pop(L,n) lua_settop(L, -(n)-1) #define lua_pop(L,n) lua_settop(L, -(n)-1)
#define lua_newtable(L) lua_createtable(L, 0, 0) #define lua_newtable(L) lua_createtable(L, 0, 0)
#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) #define lua_register(L,n,f) \
(lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) #define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) #define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) #define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) #define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) #define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) #define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) #define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) #define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) #define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
#define lua_pushliteral(L, s) \ #define lua_pushliteral(L, s) \
lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
#define lua_pushglobaltable(L) \ #define lua_pushglobaltable(L) \
lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) #define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
@ -357,20 +358,20 @@ LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
/* /*
** Event codes ** Event codes
*/ */
#define LUA_HOOKCALL 0 #define LUA_HOOKCALL 0
#define LUA_HOOKRET 1 #define LUA_HOOKRET 1
#define LUA_HOOKLINE 2 #define LUA_HOOKLINE 2
#define LUA_HOOKCOUNT 3 #define LUA_HOOKCOUNT 3
#define LUA_HOOKTAILCALL 4 #define LUA_HOOKTAILCALL 4
/* /*
** Event masks ** Event masks
*/ */
#define LUA_MASKCALL (1 << LUA_HOOKCALL) #define LUA_MASKCALL (1 << LUA_HOOKCALL)
#define LUA_MASKRET (1 << LUA_HOOKRET) #define LUA_MASKRET (1 << LUA_HOOKRET)
#define LUA_MASKLINE (1 << LUA_HOOKLINE) #define LUA_MASKLINE (1 << LUA_HOOKLINE)
#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) #define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
typedef struct lua_Debug lua_Debug; /* activation record */ typedef struct lua_Debug lua_Debug; /* activation record */
@ -398,17 +399,17 @@ LUA_API int (lua_gethookcount) (lua_State *L);
struct lua_Debug { struct lua_Debug {
int event; int event;
const char *name; /* (n) */ const char *name; /* (n) */
const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */
const char *source; /* (S) */ const char *source; /* (S) */
int currentline; /* (l) */ int currentline; /* (l) */
int linedefined; /* (S) */ int linedefined; /* (S) */
int lastlinedefined; /* (S) */ int lastlinedefined; /* (S) */
unsigned char nups; /* (u) number of upvalues */ unsigned char nups; /* (u) number of upvalues */
unsigned char nparams;/* (u) number of parameters */ unsigned char nparams;/* (u) number of parameters */
char isvararg; /* (u) */ char isvararg; /* (u) */
char istailcall; /* (t) */ char istailcall; /* (t) */
char short_src[LUA_IDSIZE]; /* (S) */ char short_src[LUA_IDSIZE]; /* (S) */
/* private part */ /* private part */
struct CallInfo *i_ci; /* active function */ struct CallInfo *i_ci; /* active function */

88
liblua/luac.c
View file

@ -20,17 +20,17 @@
#include "lundump.h" #include "lundump.h"
static void PrintFunction(const Proto* f, int full); static void PrintFunction(const Proto* f, int full);
#define luaU_print PrintFunction #define luaU_print PrintFunction
#define PROGNAME "luac" /* default program name */ #define PROGNAME "luac" /* default program name */
#define OUTPUT PROGNAME ".out" /* default output file */ #define OUTPUT PROGNAME ".out" /* default output file */
static int listing=0; /* list bytecodes? */ static int listing=0; /* list bytecodes? */
static int dumping=1; /* dump bytecodes? */ static int dumping=1; /* dump bytecodes? */
static int stripping=0; /* strip debug information? */ static int stripping=0; /* strip debug information? */
static char Output[]={ OUTPUT }; /* default output file name */ static char Output[]={ OUTPUT }; /* default output file name */
static const char* output=Output; /* actual output file name */ static const char* output=Output; /* actual output file name */
static const char* progname=PROGNAME; /* actual program name */ static const char* progname=PROGNAME; /* actual program name */
static void fatal(const char* message) static void fatal(const char* message)
{ {
@ -64,7 +64,7 @@ static void usage(const char* message)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
#define IS(s) (strcmp(argv[i],s)==0) #define IS(s) (strcmp(argv[i],s)==0)
static int doargs(int argc, char* argv[]) static int doargs(int argc, char* argv[])
{ {
@ -73,32 +73,32 @@ static int doargs(int argc, char* argv[])
if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0]; if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
for (i=1; i<argc; i++) for (i=1; i<argc; i++)
{ {
if (*argv[i]!='-') /* end of options; keep it */ if (*argv[i]!='-') /* end of options; keep it */
break; break;
else if (IS("--")) /* end of options; skip it */ else if (IS("--")) /* end of options; skip it */
{ {
++i; ++i;
if (version) ++version; if (version) ++version;
break; break;
} }
else if (IS("-")) /* end of options; use stdin */ else if (IS("-")) /* end of options; use stdin */
break; break;
else if (IS("-l")) /* list */ else if (IS("-l")) /* list */
++listing; ++listing;
else if (IS("-o")) /* output file */ else if (IS("-o")) /* output file */
{ {
output=argv[++i]; output=argv[++i];
if (output==NULL || *output==0 || (*output=='-' && output[1]!=0)) if (output==NULL || *output==0 || (*output=='-' && output[1]!=0))
usage(LUA_QL("-o") " needs argument"); usage(LUA_QL("-o") " needs argument");
if (IS("-")) output=NULL; if (IS("-")) output=NULL;
} }
else if (IS("-p")) /* parse only */ else if (IS("-p")) /* parse only */
dumping=0; dumping=0;
else if (IS("-s")) /* strip debug information */ else if (IS("-s")) /* strip debug information */
stripping=1; stripping=1;
else if (IS("-v")) /* show version */ else if (IS("-v")) /* show version */
++version; ++version;
else /* unknown option */ else /* unknown option */
usage(argv[i]); usage(argv[i]);
} }
if (i==argc && (listing || !dumping)) if (i==argc && (listing || !dumping))
@ -218,7 +218,7 @@ int main(int argc, char* argv[])
#include "lobject.h" #include "lobject.h"
#include "lopcodes.h" #include "lopcodes.h"
#define VOID(p) ((const void*)(p)) #define VOID(p) ((const void*)(p))
static void PrintString(const TString* ts) static void PrintString(const TString* ts)
{ {
@ -239,10 +239,10 @@ static void PrintString(const TString* ts)
case '\r': printf("\\r"); break; case '\r': printf("\\r"); break;
case '\t': printf("\\t"); break; case '\t': printf("\\t"); break;
case '\v': printf("\\v"); break; case '\v': printf("\\v"); break;
default: if (isprint(c)) default: if (isprint(c))
printf("%c",c); printf("%c",c);
else else
printf("\\%03d",c); printf("\\%03d",c);
} }
} }
printf("%c",'"'); printf("%c",'"');
@ -254,25 +254,25 @@ static void PrintConstant(const Proto* f, int i)
switch (ttype(o)) switch (ttype(o))
{ {
case LUA_TNIL: case LUA_TNIL:
printf("nil"); printf("nil");
break; break;
case LUA_TBOOLEAN: case LUA_TBOOLEAN:
printf(bvalue(o) ? "true" : "false"); printf(bvalue(o) ? "true" : "false");
break; break;
case LUA_TNUMBER: case LUA_TNUMBER:
printf(LUA_NUMBER_FMT,nvalue(o)); printf(LUA_NUMBER_FMT,nvalue(o));
break; break;
case LUA_TSTRING: case LUA_TSTRING:
PrintString(rawtsvalue(o)); PrintString(rawtsvalue(o));
break; break;
default: /* cannot happen */ default: /* cannot happen */
printf("? type=%d",ttype(o)); printf("? type=%d",ttype(o));
break; break;
} }
} }
#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-") #define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
#define MYK(x) (-1-(x)) #define MYK(x) (-1-(x))
static void PrintCode(const Proto* f) static void PrintCode(const Proto* f)
{ {
@ -372,8 +372,8 @@ static void PrintCode(const Proto* f)
} }
} }
#define SS(x) ((x==1)?"":"s") #define SS(x) ((x==1)?"":"s")
#define S(x) (int)(x),SS(x) #define S(x) (int)(x),SS(x)
static void PrintHeader(const Proto* f) static void PrintHeader(const Proto* f)
{ {
@ -385,14 +385,14 @@ static void PrintHeader(const Proto* f)
else else
s="(string)"; s="(string)";
printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n", printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n",
(f->linedefined==0)?"main":"function",s, (f->linedefined==0)?"main":"function",s,
f->linedefined,f->lastlinedefined, f->linedefined,f->lastlinedefined,
S(f->sizecode),VOID(f)); S(f->sizecode),VOID(f));
printf("%d%s param%s, %d slot%s, %d upvalue%s, ", printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
(int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams), (int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
S(f->maxstacksize),S(f->sizeupvalues)); S(f->maxstacksize),S(f->sizeupvalues));
printf("%d local%s, %d constant%s, %d function%s\n", printf("%d local%s, %d constant%s, %d function%s\n",
S(f->sizelocvars),S(f->sizek),S(f->sizep)); S(f->sizelocvars),S(f->sizek),S(f->sizep));
} }
static void PrintDebug(const Proto* f) static void PrintDebug(const Proto* f)

230
liblua/luaconf.h
View file

@ -30,32 +30,32 @@
#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE) #if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
#define LUA_WIN /* enable goodies for regular Windows platforms */ #define LUA_WIN /* enable goodies for regular Windows platforms */
#endif #endif
#if defined(LUA_WIN) #if defined(LUA_WIN)
#define LUA_DL_DLL #define LUA_DL_DLL
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ #define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
#endif #endif
#if defined(LUA_USE_LINUX) #if defined(LUA_USE_LINUX)
#define LUA_USE_POSIX #define LUA_USE_POSIX
#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ #define LUA_USE_DLOPEN /* needs an extra library: -ldl */
#define LUA_USE_READLINE /* needs some extra libraries */ #define LUA_USE_READLINE /* needs some extra libraries */
#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ #define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ #define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
#define LUA_USE_LONGLONG /* assume support for long long */ #define LUA_USE_LONGLONG /* assume support for long long */
#endif #endif
#if defined(LUA_USE_MACOSX) #if defined(LUA_USE_MACOSX)
#define LUA_USE_POSIX #define LUA_USE_POSIX
#define LUA_USE_DLOPEN /* does not need -ldl */ #define LUA_USE_DLOPEN /* does not need -ldl */
#define LUA_USE_READLINE /* needs an extra library: -lreadline */ #define LUA_USE_READLINE /* needs an extra library: -lreadline */
#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ #define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */
#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ #define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
#define LUA_USE_LONGLONG /* assume support for long long */ #define LUA_USE_LONGLONG /* assume support for long long */
#endif #endif
@ -84,31 +84,31 @@
** hierarchy or if you want to install your libraries in ** hierarchy or if you want to install your libraries in
** non-conventional directories. ** non-conventional directories.
*/ */
#if defined(_WIN32) /* { */ #if defined(_WIN32) /* { */
/* /*
** In Windows, any exclamation mark ('!') in the path is replaced by the ** In Windows, any exclamation mark ('!') in the path is replaced by the
** path of the directory of the executable file of the current process. ** path of the directory of the executable file of the current process.
*/ */
#define LUA_LDIR "!\\lua\\" #define LUA_LDIR "!\\lua\\"
#define LUA_CDIR "!\\" #define LUA_CDIR "!\\"
#define LUA_PATH_DEFAULT \ #define LUA_PATH_DEFAULT \
LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua" LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua"
#define LUA_CPATH_DEFAULT \ #define LUA_CPATH_DEFAULT \
LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"
#else /* }{ */ #else /* }{ */
#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/" #define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
#define LUA_ROOT "/usr/local/" #define LUA_ROOT "/usr/local/"
#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR #define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR
#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR #define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR
#define LUA_PATH_DEFAULT \ #define LUA_PATH_DEFAULT \
LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" "./?.lua" LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" "./?.lua"
#define LUA_CPATH_DEFAULT \ #define LUA_CPATH_DEFAULT \
LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
#endif /* } */ #endif /* } */
/* /*
@ -117,9 +117,9 @@
** and is not Windows. (On Windows Lua automatically uses "\".) ** and is not Windows. (On Windows Lua automatically uses "\".)
*/ */
#if defined(_WIN32) #if defined(_WIN32)
#define LUA_DIRSEP "\\" #define LUA_DIRSEP "\\"
#else #else
#define LUA_DIRSEP "/" #define LUA_DIRSEP "/"
#endif #endif
@ -128,7 +128,7 @@
@@ environment, used to access global names. @@ environment, used to access global names.
** CHANGE it if you do not like this name. ** CHANGE it if you do not like this name.
*/ */
#define LUA_ENV "_ENV" #define LUA_ENV "_ENV"
/* /*
@ -140,24 +140,24 @@
** the libraries, you may want to use the following definition (define ** the libraries, you may want to use the following definition (define
** LUA_BUILD_AS_DLL to get it). ** LUA_BUILD_AS_DLL to get it).
*/ */
#if defined(LUA_BUILD_AS_DLL) /* { */ #if defined(LUA_BUILD_AS_DLL) /* { */
#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ #if defined(LUA_CORE) || defined(LUA_LIB) /* { */
#define LUA_API __declspec(dllexport) #define LUA_API __declspec(dllexport)
#else /* }{ */ #else /* }{ */
#define LUA_API __declspec(dllimport) #define LUA_API __declspec(dllimport)
#endif /* } */ #endif /* } */
#else /* }{ */ #else /* }{ */
#define LUA_API extern #define LUA_API extern
#endif /* } */ #endif /* } */
/* more often than not the libs go together with the core */ /* more often than not the libs go together with the core */
#define LUALIB_API LUA_API #define LUALIB_API LUA_API
#define LUAMOD_API LUALIB_API #define LUAMOD_API LUALIB_API
/* /*
@ -175,16 +175,16 @@
** default definition. ** default definition.
*/ */
#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ #if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
defined(__ELF__) /* { */ defined(__ELF__) /* { */
#define LUAI_FUNC __attribute__((visibility("hidden"))) extern #define LUAI_FUNC __attribute__((visibility("hidden"))) extern
#define LUAI_DDEC LUAI_FUNC #define LUAI_DDEC LUAI_FUNC
#define LUAI_DDEF /* empty */ #define LUAI_DDEF /* empty */
#else /* }{ */ #else /* }{ */
#define LUAI_FUNC extern #define LUAI_FUNC extern
#define LUAI_DDEC extern #define LUAI_DDEC extern
#define LUAI_DDEF /* empty */ #define LUAI_DDEF /* empty */
#endif /* } */ #endif /* } */
@ -192,8 +192,8 @@
@@ LUA_QL describes how error messages quote program elements. @@ LUA_QL describes how error messages quote program elements.
** CHANGE it if you want a different appearance. ** CHANGE it if you want a different appearance.
*/ */
#define LUA_QL(x) "'" x "'" #define LUA_QL(x) "'" x "'"
#define LUA_QS LUA_QL("%s") #define LUA_QS LUA_QL("%s")
/* /*
@ -201,7 +201,7 @@
@* of a function in debug information. @* of a function in debug information.
** CHANGE it if you want a different size. ** CHANGE it if you want a different size.
*/ */
#define LUA_IDSIZE 60 #define LUA_IDSIZE 60
/* /*
@ -211,8 +211,8 @@
*/ */
#if defined(LUA_LIB) || defined(lua_c) #if defined(LUA_LIB) || defined(lua_c)
#include <stdio.h> #include <stdio.h>
#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) #define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout)) #define luai_writeline() (luai_writestring("\n", 1), fflush(stdout))
#endif #endif
/* /*
@ -220,7 +220,7 @@
** (A format string with one argument is enough for Lua...) ** (A format string with one argument is enough for Lua...)
*/ */
#define luai_writestringerror(s,p) \ #define luai_writestringerror(s,p) \
(fprintf(stderr, (s), (p)), fflush(stderr)) (fprintf(stderr, (s), (p)), fflush(stderr))
/* /*
@ -244,7 +244,7 @@
** You can define it to get all options, or change specific options ** You can define it to get all options, or change specific options
** to fit your specific needs. ** to fit your specific needs.
*/ */
#if defined(LUA_COMPAT_ALL) /* { */ #if defined(LUA_COMPAT_ALL) /* { */
/* /*
@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
@ -263,9 +263,9 @@
** You can call your C function directly (with light C functions). ** You can call your C function directly (with light C functions).
*/ */
#define lua_cpcall(L,f,u) \ #define lua_cpcall(L,f,u) \
(lua_pushcfunction(L, (f)), \ (lua_pushcfunction(L, (f)), \
lua_pushlightuserdata(L,(u)), \ lua_pushlightuserdata(L,(u)), \
lua_pcall(L,1,0,0)) lua_pcall(L,1,0,0))
/* /*
@ -290,12 +290,12 @@
** changes in the API. The macros themselves document how to ** changes in the API. The macros themselves document how to
** change your code to avoid using them. ** change your code to avoid using them.
*/ */
#define lua_strlen(L,i) lua_rawlen(L, (i)) #define lua_strlen(L,i) lua_rawlen(L, (i))
#define lua_objlen(L,i) lua_rawlen(L, (i)) #define lua_objlen(L,i) lua_rawlen(L, (i))
#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) #define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) #define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
/* /*
@@ LUA_COMPAT_MODULE controls compatibility with previous @@ LUA_COMPAT_MODULE controls compatibility with previous
@ -303,7 +303,7 @@
*/ */
#define LUA_COMPAT_MODULE #define LUA_COMPAT_MODULE
#endif /* } */ #endif /* } */
/* }================================================================== */ /* }================================================================== */
@ -315,14 +315,14 @@
** your machine. Probably you do not need to change this. ** your machine. Probably you do not need to change this.
*/ */
/* avoid overflows in comparison */ /* avoid overflows in comparison */
#if INT_MAX-20 < 32760 /* { */ #if INT_MAX-20 < 32760 /* { */
#define LUAI_BITSINT 16 #define LUAI_BITSINT 16
#elif INT_MAX > 2147483640L /* }{ */ #elif INT_MAX > 2147483640L /* }{ */
/* int has at least 32 bits */ /* int has at least 32 bits */
#define LUAI_BITSINT 32 #define LUAI_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 /* } */
/* /*
@ -335,16 +335,16 @@
** good enough for your machine. Probably you do not need to change ** good enough for your machine. Probably you do not need to change
** this. ** this.
*/ */
#if LUAI_BITSINT >= 32 /* { */ #if LUAI_BITSINT >= 32 /* { */
#define LUA_INT32 int #define LUA_INT32 int
#define LUAI_UMEM size_t #define LUAI_UMEM size_t
#define LUAI_MEM ptrdiff_t #define LUAI_MEM ptrdiff_t
#else /* }{ */ #else /* }{ */
/* 16-bit ints */ /* 16-bit ints */
#define LUA_INT32 long #define LUA_INT32 long
#define LUAI_UMEM unsigned long #define LUAI_UMEM unsigned long
#define LUAI_MEM long #define LUAI_MEM long
#endif /* } */ #endif /* } */
/* /*
@ -354,13 +354,13 @@
** space (and to reserve some numbers for pseudo-indices). ** space (and to reserve some numbers for pseudo-indices).
*/ */
#if LUAI_BITSINT >= 32 #if LUAI_BITSINT >= 32
#define LUAI_MAXSTACK 1000000 #define LUAI_MAXSTACK 1000000
#else #else
#define LUAI_MAXSTACK 15000 #define LUAI_MAXSTACK 15000
#endif #endif
/* reserve some space for error handling */ /* reserve some space for error handling */
#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) #define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000)
@ -369,7 +369,7 @@
@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
** CHANGE it if it uses too much C-stack space. ** CHANGE it if it uses too much C-stack space.
*/ */
#define LUAL_BUFFERSIZE BUFSIZ #define LUAL_BUFFERSIZE BUFSIZ
@ -384,13 +384,13 @@
*/ */
#define LUA_NUMBER_DOUBLE #define LUA_NUMBER_DOUBLE
#define LUA_NUMBER double #define LUA_NUMBER double
/* /*
@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' @@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
@* over a number. @* over a number.
*/ */
#define LUAI_UACNUMBER double #define LUAI_UACNUMBER double
/* /*
@ -399,16 +399,16 @@
@@ lua_number2str converts a number to a string. @@ lua_number2str converts a number to a string.
@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. @@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
*/ */
#define LUA_NUMBER_SCAN "%lf" #define LUA_NUMBER_SCAN "%lf"
#define LUA_NUMBER_FMT "%.14g" #define LUA_NUMBER_FMT "%.14g"
#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ #define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
/* /*
@@ l_mathop allows the addition of an 'l' or 'f' to all math operations @@ l_mathop allows the addition of an 'l' or 'f' to all math operations
*/ */
#define l_mathop(x) (x) #define l_mathop(x) (x)
/* /*
@ -419,10 +419,10 @@
** systems, you can leave 'lua_strx2number' undefined and Lua will ** systems, you can leave 'lua_strx2number' undefined and Lua will
** provide its own implementation. ** provide its own implementation.
*/ */
#define lua_str2number(s,p) strtod((s), (p)) #define lua_str2number(s,p) strtod((s), (p))
#if defined(LUA_USE_STRTODHEX) #if defined(LUA_USE_STRTODHEX)
#define lua_strx2number(s,p) strtod((s), (p)) #define lua_strx2number(s,p) strtod((s), (p))
#endif #endif
@ -433,21 +433,21 @@
/* the following operations need the math library */ /* the following operations need the math library */
#if defined(lobject_c) || defined(lvm_c) #if defined(lobject_c) || defined(lvm_c)
#include <math.h> #include <math.h>
#define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b)) #define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b))
#define luai_numpow(L,a,b) (l_mathop(pow)(a,b)) #define luai_numpow(L,a,b) (l_mathop(pow)(a,b))
#endif #endif
/* these are quite standard operations */ /* these are quite standard operations */
#if defined(LUA_CORE) #if defined(LUA_CORE)
#define luai_numadd(L,a,b) ((a)+(b)) #define luai_numadd(L,a,b) ((a)+(b))
#define luai_numsub(L,a,b) ((a)-(b)) #define luai_numsub(L,a,b) ((a)-(b))
#define luai_nummul(L,a,b) ((a)*(b)) #define luai_nummul(L,a,b) ((a)*(b))
#define luai_numdiv(L,a,b) ((a)/(b)) #define luai_numdiv(L,a,b) ((a)/(b))
#define luai_numunm(L,a) (-(a)) #define luai_numunm(L,a) (-(a))
#define luai_numeq(a,b) ((a)==(b)) #define luai_numeq(a,b) ((a)==(b))
#define luai_numlt(L,a,b) ((a)<(b)) #define luai_numlt(L,a,b) ((a)<(b))
#define luai_numle(L,a,b) ((a)<=(b)) #define luai_numle(L,a,b) ((a)<=(b))
#define luai_numisnan(L,a) (!luai_numeq((a), (a))) #define luai_numisnan(L,a) (!luai_numeq((a), (a)))
#endif #endif
@ -457,13 +457,13 @@
** CHANGE that if ptrdiff_t is not adequate on your machine. (On most ** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
** machines, ptrdiff_t gives a good choice between int or long.) ** machines, ptrdiff_t gives a good choice between int or long.)
*/ */
#define LUA_INTEGER ptrdiff_t #define LUA_INTEGER ptrdiff_t
/* /*
@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned. @@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
** It must have at least 32 bits. ** It must have at least 32 bits.
*/ */
#define LUA_UNSIGNED unsigned LUA_INT32 #define LUA_UNSIGNED unsigned LUA_INT32
@ -471,7 +471,7 @@
** Some tricks with doubles ** Some tricks with doubles
*/ */
#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */ #if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
/* /*
** The next definitions activate some tricks to speed up the ** The next definitions activate some tricks to speed up the
** conversion from doubles to integer types, mainly to LUA_UNSIGNED. ** conversion from doubles to integer types, mainly to LUA_UNSIGNED.
@ -498,10 +498,10 @@
*/ */
/* Microsoft compiler on a Pentium (32 bit) ? */ /* Microsoft compiler on a Pentium (32 bit) ? */
#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */ #if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */
#define LUA_MSASMTRICK #define LUA_MSASMTRICK
#define LUA_IEEEENDIAN 0 #define LUA_IEEEENDIAN 0
#define LUA_NANTRICK #define LUA_NANTRICK
@ -510,28 +510,28 @@
#define LUA_IEEE754TRICK #define LUA_IEEE754TRICK
#define LUA_IEEELL #define LUA_IEEELL
#define LUA_IEEEENDIAN 0 #define LUA_IEEEENDIAN 0
#define LUA_NANTRICK #define LUA_NANTRICK
/* pentium 64 bits? */ /* pentium 64 bits? */
#elif defined(__x86_64) /* }{ */ #elif defined(__x86_64) /* }{ */
#define LUA_IEEE754TRICK #define LUA_IEEE754TRICK
#define LUA_IEEEENDIAN 0 #define LUA_IEEEENDIAN 0
#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */ #elif defined(__POWERPC__) || defined(__ppc__) /* }{ */
#define LUA_IEEE754TRICK #define LUA_IEEE754TRICK
#define LUA_IEEEENDIAN 1 #define LUA_IEEEENDIAN 1
#else /* }{ */ #else /* }{ */
/* assume IEEE754 and a 32-bit integer type */ /* assume IEEE754 and a 32-bit integer type */
#define LUA_IEEE754TRICK #define LUA_IEEE754TRICK
#endif /* } */ #endif /* } */
#endif /* } */ #endif /* } */
/* }================================================================== */ /* }================================================================== */

20
liblua/lualib.h
View file

@ -14,31 +14,31 @@
LUAMOD_API int (luaopen_base) (lua_State *L); LUAMOD_API int (luaopen_base) (lua_State *L);
#define LUA_COLIBNAME "coroutine" #define LUA_COLIBNAME "coroutine"
LUAMOD_API int (luaopen_coroutine) (lua_State *L); LUAMOD_API int (luaopen_coroutine) (lua_State *L);
#define LUA_TABLIBNAME "table" #define LUA_TABLIBNAME "table"
LUAMOD_API int (luaopen_table) (lua_State *L); LUAMOD_API int (luaopen_table) (lua_State *L);
#define LUA_IOLIBNAME "io" #define LUA_IOLIBNAME "io"
LUAMOD_API int (luaopen_io) (lua_State *L); LUAMOD_API int (luaopen_io) (lua_State *L);
#define LUA_OSLIBNAME "os" #define LUA_OSLIBNAME "os"
LUAMOD_API int (luaopen_os) (lua_State *L); LUAMOD_API int (luaopen_os) (lua_State *L);
#define LUA_STRLIBNAME "string" #define LUA_STRLIBNAME "string"
LUAMOD_API int (luaopen_string) (lua_State *L); LUAMOD_API int (luaopen_string) (lua_State *L);
#define LUA_BITLIBNAME "bit32" #define LUA_BITLIBNAME "bit32"
LUAMOD_API int (luaopen_bit32) (lua_State *L); LUAMOD_API int (luaopen_bit32) (lua_State *L);
#define LUA_MATHLIBNAME "math" #define LUA_MATHLIBNAME "math"
LUAMOD_API int (luaopen_math) (lua_State *L); LUAMOD_API int (luaopen_math) (lua_State *L);
#define LUA_DBLIBNAME "debug" #define LUA_DBLIBNAME "debug"
LUAMOD_API int (luaopen_debug) (lua_State *L); LUAMOD_API int (luaopen_debug) (lua_State *L);
#define LUA_LOADLIBNAME "package" #define LUA_LOADLIBNAME "package"
LUAMOD_API int (luaopen_package) (lua_State *L); LUAMOD_API int (luaopen_package) (lua_State *L);
@ -48,7 +48,7 @@ LUALIB_API void (luaL_openlibs) (lua_State *L);
#if !defined(lua_assert) #if !defined(lua_assert)
#define lua_assert(x) ((void)0) #define lua_assert(x) ((void)0)
#endif #endif

48
liblua/lundump.c
View file

@ -33,13 +33,13 @@ static l_noret error(LoadState* S, const char* why)
luaD_throw(S->L,LUA_ERRSYNTAX); luaD_throw(S->L,LUA_ERRSYNTAX);
} }
#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size)) #define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
#define LoadByte(S) (lu_byte)LoadChar(S) #define LoadByte(S) (lu_byte)LoadChar(S)
#define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x)) #define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x))
#define LoadVector(S,b,n,size) LoadMem(S,b,n,size) #define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
#if !defined(luai_verifycode) #if !defined(luai_verifycode)
#define luai_verifycode(L,b,f) /* empty */ #define luai_verifycode(L,b,f) /* empty */
#endif #endif
static void LoadBlock(LoadState* S, void* b, size_t size) static void LoadBlock(LoadState* S, void* b, size_t size)
@ -79,7 +79,7 @@ static TString* LoadString(LoadState* S)
{ {
char* s=luaZ_openspace(S->L,S->b,size); char* s=luaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size*sizeof(char)); LoadBlock(S,s,size*sizeof(char));
return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
} }
} }
@ -107,17 +107,17 @@ static void LoadConstants(LoadState* S, Proto* f)
switch (t) switch (t)
{ {
case LUA_TNIL: case LUA_TNIL:
setnilvalue(o); setnilvalue(o);
break; break;
case LUA_TBOOLEAN: case LUA_TBOOLEAN:
setbvalue(o,LoadChar(S)); setbvalue(o,LoadChar(S));
break; break;
case LUA_TNUMBER: case LUA_TNUMBER:
setnvalue(o,LoadNumber(S)); setnvalue(o,LoadNumber(S));
break; break;
case LUA_TSTRING: case LUA_TSTRING:
setsvalue2n(S->L,o,LoadString(S)); setsvalue2n(S->L,o,LoadString(S));
break; break;
default: lua_assert(0); default: lua_assert(0);
} }
} }
@ -182,17 +182,17 @@ static void LoadFunction(LoadState* S, Proto* f)
} }
/* the code below must be consistent with the code in luaU_header */ /* the code below must be consistent with the code in luaU_header */
#define N0 LUAC_HEADERSIZE #define N0 LUAC_HEADERSIZE
#define N1 (sizeof(LUA_SIGNATURE)-sizeof(char)) #define N1 (sizeof(LUA_SIGNATURE)-sizeof(char))
#define N2 N1+2 #define N2 N1+2
#define N3 N2+6 #define N3 N2+6
static void LoadHeader(LoadState* S) static void LoadHeader(LoadState* S)
{ {
lu_byte h[LUAC_HEADERSIZE]; lu_byte h[LUAC_HEADERSIZE];
lu_byte s[LUAC_HEADERSIZE]; lu_byte s[LUAC_HEADERSIZE];
luaU_header(h); luaU_header(h);
memcpy(s,h,sizeof(char)); /* first char already read */ memcpy(s,h,sizeof(char)); /* first char already read */
LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char)); LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
if (memcmp(h,s,N0)==0) return; if (memcmp(h,s,N0)==0) return;
if (memcmp(h,s,N1)!=0) error(S,"not a"); if (memcmp(h,s,N1)!=0) error(S,"not a");
@ -232,9 +232,9 @@ Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
return cl; return cl;
} }
#define MYINT(s) (s[0]-'0') #define MYINT(s) (s[0]-'0')
#define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR) #define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)
#define FORMAT 0 /* this is the official format */ #define FORMAT 0 /* this is the official format */
/* /*
* make header for precompiled chunks * make header for precompiled chunks
@ -248,11 +248,11 @@ void luaU_header (lu_byte* h)
h+=sizeof(LUA_SIGNATURE)-sizeof(char); h+=sizeof(LUA_SIGNATURE)-sizeof(char);
*h++=cast_byte(VERSION); *h++=cast_byte(VERSION);
*h++=cast_byte(FORMAT); *h++=cast_byte(FORMAT);
*h++=cast_byte(*(char*)&x); /* endianness */ *h++=cast_byte(*(char*)&x); /* endianness */
*h++=cast_byte(sizeof(int)); *h++=cast_byte(sizeof(int));
*h++=cast_byte(sizeof(size_t)); *h++=cast_byte(sizeof(size_t));
*h++=cast_byte(sizeof(Instruction)); *h++=cast_byte(sizeof(Instruction));
*h++=cast_byte(sizeof(lua_Number)); *h++=cast_byte(sizeof(lua_Number));
*h++=cast_byte(((lua_Number)0.5)==0); /* is lua_Number integral? */ *h++=cast_byte(((lua_Number)0.5)==0); /* is lua_Number integral? */
memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char)); memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));
} }

4
liblua/lundump.h
View file

@ -20,9 +20,9 @@ LUAI_FUNC void luaU_header (lu_byte* h);
LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
/* data to catch conversion errors */ /* data to catch conversion errors */
#define LUAC_TAIL "\x19\x93\r\n\x1a\n" #define LUAC_TAIL "\x19\x93\r\n\x1a\n"
/* size in bytes of header of binary files */ /* size in bytes of header of binary files */
#define LUAC_HEADERSIZE (sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char)) #define LUAC_HEADERSIZE (sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
#endif #endif

28
liblua/lvm.c
View file

@ -29,7 +29,7 @@
/* limit for table tag-method chains (to avoid loops) */ /* limit for table tag-method chains (to avoid loops) */
#define MAXTAGLOOP 100 #define MAXTAGLOOP 100
const TValue *luaV_tonumber (const TValue *obj, TValue *n) { const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
@ -482,18 +482,18 @@ void luaV_finishOp (lua_State *L) {
*/ */
#if !defined luai_runtimecheck #if !defined luai_runtimecheck
#define luai_runtimecheck(L, c) /* void */ #define luai_runtimecheck(L, c) /* void */
#endif #endif
#define RA(i) (base+GETARG_A(i)) #define RA(i) (base+GETARG_A(i))
/* to be used after possible stack reallocation */ /* to be used after possible stack reallocation */
#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
#define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
#define KBx(i) \ #define KBx(i) \
(k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++))) (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++)))
@ -505,10 +505,10 @@ void luaV_finishOp (lua_State *L) {
ci->u.l.savedpc += GETARG_sBx(i) + e; } ci->u.l.savedpc += GETARG_sBx(i) + e; }
/* for test instructions, execute the jump instruction that follows it */ /* for test instructions, execute the jump instruction that follows it */
#define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); } #define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); }
#define Protect(x) { {x;}; base = ci->u.l.base; } #define Protect(x) { {x;}; base = ci->u.l.base; }
#define checkGC(L,c) \ #define checkGC(L,c) \
Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \
@ -527,9 +527,9 @@ void luaV_finishOp (lua_State *L) {
else { Protect(luaV_arith(L, ra, rb, rc, tm)); } } else { Protect(luaV_arith(L, ra, rb, rc, tm)); } }
#define vmdispatch(o) switch(o) #define vmdispatch(o) switch(o)
#define vmcase(l,b) case l: {b} break; #define vmcase(l,b) case l: {b} break;
#define vmcasenb(l,b) case l: {b} /* nb = no break */ #define vmcasenb(l,b) case l: {b} /* nb = no break */
void luaV_execute (lua_State *L) { void luaV_execute (lua_State *L) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;

4
liblua/lvm.h
View file

@ -15,11 +15,11 @@
#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o))) #define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
#define tonumber(o,n) (ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL)) #define tonumber(o,n) (ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL))
#define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2)) #define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2))
#define luaV_rawequalobj(o1,o2) equalobj(NULL,o1,o2) #define luaV_rawequalobj(o1,o2) equalobj(NULL,o1,o2)
/* not to called directly */ /* not to called directly */

26
liblua/lzio.h
View file

@ -13,7 +13,7 @@
#include "lmem.h" #include "lmem.h"
#define EOZ (-1) /* end of stream */ #define EOZ (-1) /* end of stream */
typedef struct Zio ZIO; typedef struct Zio ZIO;
@ -28,35 +28,35 @@ typedef struct Mbuffer {
#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
#define luaZ_buffer(buff) ((buff)->buffer) #define luaZ_buffer(buff) ((buff)->buffer)
#define luaZ_sizebuffer(buff) ((buff)->buffsize) #define luaZ_sizebuffer(buff) ((buff)->buffsize)
#define luaZ_bufflen(buff) ((buff)->n) #define luaZ_bufflen(buff) ((buff)->n)
#define luaZ_resetbuffer(buff) ((buff)->n = 0) #define luaZ_resetbuffer(buff) ((buff)->n = 0)
#define luaZ_resizebuffer(L, buff, size) \ #define luaZ_resizebuffer(L, buff, size) \
(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
(buff)->buffsize = size) (buff)->buffsize = size)
#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
void *data); void *data);
LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */
/* --------- Private Part ------------------ */ /* --------- Private Part ------------------ */
struct Zio { struct Zio {
size_t n; /* bytes still unread */ size_t n; /* bytes still unread */
const char *p; /* current position in buffer */ const char *p; /* current position in buffer */
lua_Reader reader; /* reader function */ lua_Reader reader; /* reader function */
void* data; /* additional data */ void* data; /* additional data */
lua_State *L; /* Lua state (for reader) */ lua_State *L; /* Lua state (for reader) */
}; };