liblua: fix mix of spaces & tabs

2026-05-12 11:18:11 -07:00 · 2019-03-09 18:16:50 +01:00
parent 89db6064d0
commit 2b1b76c2a9
53 changed files with 1030 additions and 1029 deletions
@@ -35,21 +35,21 @@ const char lua_ident[] =


 /* value at a non-valid index */
-#define NONVALIDVALUE		cast(TValue *, luaO_nilobject)
+#define NONVALIDVALUE cast(TValue *, luaO_nilobject)

 /* corresponding test */
-#define isvalid(o)	((o) != luaO_nilobject)
+#define isvalid(o) ((o) != luaO_nilobject)

 /* test for pseudo index */
-#define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
+#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX)

 /* 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_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) {
@@ -874,7 +874,7 @@ LUA_API void lua_setuservalue (lua_State *L, int idx) {

 #define checkresults(L,na,nr) \
     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) {
@@ -12,13 +12,13 @@
 #include "lstate.h"

 #define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
-				"stack overflow");}
+                "stack overflow");}

 #define adjustresults(L,nres) \
    { 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), \
-				  "not enough elements in the stack")
+#define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \
+                  "not enough elements in the stack")


 #endif
@@ -31,8 +31,8 @@
 */


-#define LEVELS1	12	/* size of the first part of the stack */
-#define LEVELS2	10	/* size of the second 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 */



@@ -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)

@@ -241,7 +241,7 @@ LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {

 #endif

-#endif				/* } */
+#endif                    /* } */


 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
 ** 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 */
-#define freelist	0
+#define freelist 0


 LUALIB_API int luaL_ref (lua_State *L, int t) {
@@ -27,7 +27,7 @@ typedef struct luaL_Reg {


 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_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,
                                               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,
                                   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)

-#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)	\
-		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
-#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), 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_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+#define luaL_argcheck(L, cond,numarg,extramsg) \
+        ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), 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_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
+#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) \
-	(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) \
-	(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)), \
   ((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 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 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,
                                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

@@ -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) {
  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
 ** optional arguments (chunk, source name, mode, and environment).
 */
-#define RESERVEDSLOT	5
+#define RESERVEDSLOT 5


 /*
@@ -15,18 +15,18 @@

 /* number of bits to consider in a number */
 #if !defined(LUA_NBITS)
-#define LUA_NBITS	32
+#define LUA_NBITS 32
 #endif


-#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
+#define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))

 /* 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) */
-#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
+#define mask(n) (~((ALLONES << 1) << ((n) - 1)))


 typedef lua_Unsigned b_uint;
@@ -26,7 +26,7 @@
 #include "lvm.h"


-#define hasjumps(e)	((e)->t != (e)->f)
+#define hasjumps(e) ((e)->t != (e)->f)


 static int isnumeral(expdesc *e) {
@@ -36,13 +36,13 @@ typedef enum BinOpr {
 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_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
@@ -9,44 +9,44 @@

 #include "lctype.h"

-#if !LUA_USE_CTYPE	/* { */
+#if !LUA_USE_CTYPE /* { */

 #include <limits.h>

 LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
  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,  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,
-  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,
-  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,
-  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,	/* 5. */
+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,    /* 5. */
  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,	/* 7. */
+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,    /* 7. */
  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,	/* 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,	/* 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,	/* 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,	/* 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,	/* 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,	/* 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,	/* f. */
+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,    /* f. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 };

-#endif			/* } */
+#endif             /* } */
@@ -20,58 +20,58 @@

 #if 'A' == 65 && '0' == 48
 /* ASCII case: can use its own tables; faster and fixed */
-#define LUA_USE_CTYPE	0
+#define LUA_USE_CTYPE 0
 #else
 /* must use standard C ctype */
-#define LUA_USE_CTYPE	1
+#define LUA_USE_CTYPE 1
 #endif

 #endif


-#if !LUA_USE_CTYPE	/* { */
+#if !LUA_USE_CTYPE /* { */

 #include <limits.h>

 #include "llimits.h"


-#define ALPHABIT	0
-#define DIGITBIT	1
-#define PRINTBIT	2
-#define SPACEBIT	3
-#define XDIGITBIT	4
+#define ALPHABIT  0
+#define DIGITBIT  1
+#define PRINTBIT  2
+#define SPACEBIT  3
+#define XDIGITBIT 4


-#define MASK(B)		(1 << (B))
+#define MASK(B) (1 << (B))


 /*
 ** 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 '_'
 */
-#define lislalpha(c)	testprop(c, MASK(ALPHABIT))
-#define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
-#define lisdigit(c)	testprop(c, MASK(DIGITBIT))
-#define lisspace(c)	testprop(c, MASK(SPACEBIT))
-#define lisprint(c)	testprop(c, MASK(PRINTBIT))
-#define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
+#define lislalpha(c) testprop(c, MASK(ALPHABIT))
+#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
+#define lisdigit(c)  testprop(c, MASK(DIGITBIT))
+#define lisspace(c)  testprop(c, MASK(SPACEBIT))
+#define lisprint(c)  testprop(c, MASK(PRINTBIT))
+#define lisxdigit(c) testprop(c, MASK(XDIGITBIT))

 /*
 ** 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) */
 LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];


-#else			/* }{ */
+#else               /* }{ */

 /*
 ** use standard C ctypes
@@ -80,16 +80,16 @@ LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
 #include <ctype.h>


-#define lislalpha(c)	(isalpha(c) || (c) == '_')
-#define lislalnum(c)	(isalnum(c) || (c) == '_')
-#define lisdigit(c)	(isdigit(c))
-#define lisspace(c)	(isspace(c))
-#define lisprint(c)	(isprint(c))
-#define lisxdigit(c)	(isxdigit(c))
+#define lislalpha(c) (isalpha(c) || (c) == '_')
+#define lislalnum(c) (isalnum(c) || (c) == '_')
+#define lisdigit(c)  (isdigit(c))
+#define lisspace(c)  (isspace(c))
+#define lisprint(c)  (isprint(c))
+#define lisxdigit(c) (isxdigit(c))

-#define ltolower(c)	(tolower(c))
+#define ltolower(c) (tolower(c))

-#endif			/* } */
+#endif              /* } */

 #endif

@@ -18,7 +18,7 @@
 #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) {
@@ -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);
@@ -11,14 +11,14 @@
 #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) */
-#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,
@@ -50,22 +50,22 @@

 #if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)
 /* C++ exceptions */
-#define LUAI_THROW(L,c)		throw(c)
+#define LUAI_THROW(L,c) throw(c)
 #define LUAI_TRY(L,c,a) \
-	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
-#define luai_jmpbuf		int  /* dummy variable */
+    try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
+#define luai_jmpbuf int  /* dummy variable */

 #elif defined(LUA_USE_ULONGJMP)
 /* in Unix, try _longjmp/_setjmp (more efficient) */
-#define LUAI_THROW(L,c)		_longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)		if (_setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf		jmp_buf
+#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf jmp_buf

 #else
 /* default handling with long jumps */
-#define LUAI_THROW(L,c)		longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)		if (setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf		jmp_buf
+#define LUAI_THROW(L,c) longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf jmp_buf

 #endif

@@ -155,7 +155,7 @@ static void correctstack (lua_State *L, TValue *oldstack) {


 /* some space for error handling */
-#define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
+#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200)


 void luaD_reallocstack (lua_State *L, int newsize) {
@@ -13,14 +13,14 @@
 #include "lzio.h"


-#define luaD_checkstack(L,n)	if (L->stack_last - L->top <= (n)) \
-				    luaD_growstack(L, n); else condmovestack(L);
+#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \
+                    luaD_growstack(L, n); else condmovestack(L);


 #define incr_top(L) {L->top++; luaD_checkstack(L,0);}

-#define savestack(L,p)		((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
+#define savestack(L,p)    ((char *)(p) - (char *)L->stack)
+#define restorestack(L,n) ((TValue *)((char *)L->stack + (n)))


 /* type of protected functions, to be ran by `runprotected' */
@@ -23,8 +23,8 @@ typedef struct {
 int status;
 } DumpState;

-#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
-#define DumpVar(x,D)		DumpMem(&x,1,sizeof(x),D)
+#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D)
+#define DumpVar(x,D)        DumpMem(&x,1,sizeof(x),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
 {
-  size_t size=s->tsv.len+1;		/* include trailing '\0' */
+  size_t size=s->tsv.len+1; /* include trailing '\0' */
  DumpVar(size,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);

@@ -88,16 +88,16 @@ static void DumpConstants(const Proto* f, DumpState* D)
  switch (ttypenv(o))
  {
   case LUA_TNIL:
-	break;
+    break;
   case LUA_TBOOLEAN:
-	DumpChar(bvalue(o),D);
-	break;
+    DumpChar(bvalue(o),D);
+    break;
   case LUA_TNUMBER:
-	DumpNumber(nvalue(o),D);
-	break;
+    DumpNumber(nvalue(o),D);
+    break;
   case LUA_TSTRING:
-	DumpString(rawtsvalue(o),D);
-	break;
+    DumpString(rawtsvalue(o),D);
+    break;
    default: lua_assert(0);
  }
 }
@@ -11,10 +11,10 @@
 #include "lobject.h"


-#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
+#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \
                         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)))


@@ -28,44 +28,44 @@
 ** cost of sweeping one element (the size of a small object divided
 ** 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 */
-#define GCSWEEPMAX	(cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
+#define GCSWEEPMAX  (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))

 /* 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
 ** 'stepmul / STEPMULADJ' (value chosen by tests)
 */
-#define STEPMULADJ		200
+#define STEPMULADJ    200


 /*
 ** macro to adjust 'pause': 'pause' is actually used like
 ** 'pause / PAUSEADJ' (value chosen by tests)
 */
-#define PAUSEADJ		100
+#define PAUSEADJ      100


 /*
 ** 'makewhite' erases all color bits plus the old bit and then
 ** sets only the current white bit
 */
-#define maskcolors	(~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS))
-#define makewhite(g,x)	\
+#define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS))
+#define makewhite(g,x) \
 (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g)))

-#define white2gray(x)	resetbits(gch(x)->marked, WHITEBITS)
-#define black2gray(x)	resetbit(gch(x)->marked, BLACKBIT)
+#define white2gray(x) resetbits(gch(x)->marked, WHITEBITS)
+#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)  \
@@ -76,7 +76,7 @@
  if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }

 #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);

@@ -91,13 +91,13 @@ static void reallymarkobject (global_State *g, GCObject *o);
 /*
 ** 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'
 */
-#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);


@@ -915,7 +915,7 @@ static void setpause (global_State *g, l_mem estimate) {


 #define sweepphases  \
-	(bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep))
+    (bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep))


 /*
@@ -29,25 +29,25 @@
 /* how much to allocate before next GC step */
 #if !defined(GCSTEPSIZE)
 /* ~100 small strings */
-#define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
+#define GCSTEPSIZE (cast_int(100 * sizeof(TString)))
 #endif


 /*
 ** Possible states of the Garbage Collector
 */
-#define GCSpropagate	0
-#define GCSatomic	1
-#define GCSsweepstring	2
-#define GCSsweepudata	3
-#define GCSsweep	4
-#define GCSpause	5
+#define GCSpropagate   0
+#define GCSatomic      1
+#define GCSsweepstring 2
+#define GCSsweepudata  3
+#define GCSsweep       4
+#define GCSpause       5


 #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
@@ -58,7 +58,7 @@
 ** 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
 */
-#define resetbits(x,m)		((x) &= cast(lu_byte, ~(m)))
-#define setbits(x,m)		((x) |= (m))
-#define testbits(x,m)		((x) & (m))
-#define bitmask(b)		(1<<(b))
-#define bit2mask(b1,b2)		(bitmask(b1) | bitmask(b2))
-#define l_setbit(x,b)		setbits(x, bitmask(b))
-#define resetbit(x,b)		resetbits(x, bitmask(b))
-#define testbit(x,b)		testbits(x, bitmask(b))
+#define resetbits(x,m)  ((x) &= cast(lu_byte, ~(m)))
+#define setbits(x,m)    ((x) |= (m))
+#define testbits(x,m)   ((x) & (m))
+#define bitmask(b)      (1<<(b))
+#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
+#define l_setbit(x,b)   setbits(x, bitmask(b))
+#define resetbit(x,b)   resetbits(x, bitmask(b))
+#define testbit(x,b)    testbits(x, bitmask(b))


 /* Layout for bit use in `marked' field: */
-#define WHITE0BIT	0  /* object is white (type 0) */
-#define WHITE1BIT	1  /* object is white (type 1) */
-#define BLACKBIT	2  /* object is black */
-#define FINALIZEDBIT	3  /* object has been separated for finalization */
-#define SEPARATED	4  /* object is in 'finobj' list or in 'tobefnz' */
-#define FIXEDBIT	5  /* object is fixed (should not be collected) */
-#define OLDBIT		6  /* object is old (only in generational mode) */
+#define WHITE0BIT    0  /* object is white (type 0) */
+#define WHITE1BIT    1  /* object is white (type 1) */
+#define BLACKBIT     2  /* object is black */
+#define FINALIZEDBIT 3  /* object has been separated for finalization */
+#define SEPARATED    4  /* object is in 'finobj' list or in 'tobefnz' */
+#define FIXEDBIT     5  /* object is fixed (should not be collected) */
+#define OLDBIT       6  /* object is old (only in generational mode) */
 /* 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 isblack(x)      testbit((x)->gch.marked, BLACKBIT)
 #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
   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 isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
-#define isdead(g,v)	isdeadm(otherwhite(g), (v)->gch.marked)
+#define otherwhite(g) (g->currentwhite ^ WHITEBITS)
+#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
+#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)

-#define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
-#define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
+#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
+#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) \
-	{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
-#define luaC_checkGC(L)		luaC_condGC(L, luaC_step(L);)
+    {if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
+#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)


 #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)))  \
-	luaC_barrierback_(L,p); }
+    luaC_barrierback_(L,p); }

 #define luaC_objbarrier(L,p,o)  \
-	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
-		luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
+    { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
+        luaC_barrier_(L,obj2gco(p),obj2gco(o)); }

 #define luaC_objbarrierback(L,p,o)  \
   { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }
@@ -37,10 +37,10 @@
 ** the standard ones.
 */
 #define lua_checkmode(mode) \
-	(*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&	\
-	(*mode != '+' || ++mode) &&  /* skip if char is '+' */	\
-	(*mode != 'b' || ++mode) &&  /* skip if char is 'b' */	\
-	(*mode == '\0'))
+    (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \
+    (*mode != '+' || ++mode) &&  /* skip if char is '+' */ \
+    (*mode != 'b' || ++mode) &&  /* skip if char is 'b' */ \
+    (*mode == '\0'))

 #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_pclose(L,file)	((void)L, pclose(file))
+#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))
+#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_pclose(L,file)		((void)L, _pclose(file))
+#define lua_popen(L,c,m) ((void)L, _popen(c,m))
+#define lua_pclose(L,file) ((void)L, _pclose(file))


-#else				/* }{ */
+#else                      /* }{ */

-#define lua_popen(L,c,m)		((void)((void)c, m),  \
-		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)		((void)((void)L, file), -1)
+#define lua_popen(L,c,m) ((void)((void)c, m),  \
+        luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
+#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)

-#define l_fseek(f,o,w)		fseeko(f,o,w)
-#define l_ftell(f)		ftello(f)
-#define l_seeknum		off_t
+#define l_fseek(f,o,w) fseeko(f,o,w)
+#define l_ftell(f) ftello(f)
+#define l_seeknum off_t

 #elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
   && defined(_MSC_VER) && (_MSC_VER >= 1400)
 /* Windows (but not DDK) and Visual C++ 2005 or higher */

-#define l_fseek(f,o,w)		_fseeki64(f,o,w)
-#define l_ftell(f)		_ftelli64(f)
-#define l_seeknum		__int64
+#define l_fseek(f,o,w) _fseeki64(f,o,w)
+#define l_ftell(f) _ftelli64(f)
+#define l_seeknum __int64

 #else

-#define l_fseek(f,o,w)		fseek(f,o,w)
-#define l_ftell(f)		ftell(f)
-#define l_seeknum		long
+#define l_fseek(f,o,w) fseek(f,o,w)
+#define l_ftell(f) ftell(f)
+#define l_seeknum long

 #endif

-#endif			/* } */
+#endif                   /* } */

 /* }====================================================== */


-#define IO_PREFIX	"_IO_"
-#define IO_INPUT	(IO_PREFIX "input")
-#define IO_OUTPUT	(IO_PREFIX "output")
+#define IO_PREFIX "_IO_"
+#define IO_INPUT (IO_PREFIX "input")
+#define IO_OUTPUT (IO_PREFIX "output")


 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) {
@@ -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) {
  size_t rlen = LUAL_BUFFERSIZE;  /* how much to read in each cycle */
--- a/Show More
+++ b/Show More