[Scummvm-cvs-logs] SF.net SVN: scummvm:[33411] residual/trunk/engine/lua

aquadran at users.sourceforge.net aquadran at users.sourceforge.net
Tue Jul 29 16:57:15 CEST 2008


Revision: 33411
          http://scummvm.svn.sourceforge.net/scummvm/?rev=33411&view=rev
Author:   aquadran
Date:     2008-07-29 14:57:13 +0000 (Tue, 29 Jul 2008)

Log Message:
-----------
formating code

Modified Paths:
--------------
    residual/trunk/engine/lua/ldo.cpp
    residual/trunk/engine/lua/llex.h
    residual/trunk/engine/lua/lmathlib.cpp
    residual/trunk/engine/lua/lmem.cpp
    residual/trunk/engine/lua/lmem.h
    residual/trunk/engine/lua/lobject.cpp
    residual/trunk/engine/lua/lobject.h
    residual/trunk/engine/lua/lopcodes.h
    residual/trunk/engine/lua/lparser.cpp
    residual/trunk/engine/lua/lparser.h
    residual/trunk/engine/lua/lrestore.cpp
    residual/trunk/engine/lua/lsave.cpp
    residual/trunk/engine/lua/lstate.cpp
    residual/trunk/engine/lua/lstate.h
    residual/trunk/engine/lua/lstring.cpp
    residual/trunk/engine/lua/ltable.cpp
    residual/trunk/engine/lua/ltable.h
    residual/trunk/engine/lua/ltask.cpp
    residual/trunk/engine/lua/ltask.h
    residual/trunk/engine/lua/ltm.cpp
    residual/trunk/engine/lua/ltm.h
    residual/trunk/engine/lua/lua.h
    residual/trunk/engine/lua/luadebug.h
    residual/trunk/engine/lua/lualib.h
    residual/trunk/engine/lua/lundump.cpp
    residual/trunk/engine/lua/lvm.cpp
    residual/trunk/engine/lua/lvm.h
    residual/trunk/engine/lua/lzio.h

Modified: residual/trunk/engine/lua/ldo.cpp
===================================================================
--- residual/trunk/engine/lua/ldo.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/ldo.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -205,7 +205,7 @@
 		L->ci->tf = NULL;
 		L->ci->pc = NULL;
 	} else {
-		Byte *pc = tfvalue(f)->code;
+		byte *pc = tfvalue(f)->code;
 		if (lua_callhook)
 			luaD_callHook(base, tfvalue(f), 0);
 		luaD_checkstack((*pc++) + EXTRA_STACK);

Modified: residual/trunk/engine/lua/llex.h
===================================================================
--- residual/trunk/engine/lua/llex.h	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/llex.h	2008-07-29 14:57:13 UTC (rev 33411)
@@ -7,8 +7,8 @@
 #ifndef llex_h
 #define llex_h
 
-#include "lobject.h"
-#include "lzio.h"
+#include "engine/lua/lobject.h"
+#include "engine/lua/lzio.h"
 
 #define FIRST_RESERVED	260
 

Modified: residual/trunk/engine/lua/lmathlib.cpp
===================================================================
--- residual/trunk/engine/lua/lmathlib.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lmathlib.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -5,168 +5,147 @@
 */
 
 
-#include "lauxlib.h"
-#include "lua.h"
-#include "lualib.h"
+#include "engine/lua/lauxlib.h"
+#include "engine/lua/lua.h"
+#include "engine/lua/lualib.h"
 
 #ifndef LOCAL_PI
 #define LOCAL_PI          (3.14159265358979323846)
 #endif
 
-
 #define FROMRAD(a) ((a)*(180.0/LOCAL_PI))
 #define TORAD(a)    ((a)*(LOCAL_PI/180.0))
 
+static void math_abs() {
+	double d = luaL_check_number(1);
+	if (d < 0)
+		d = -d;
+	lua_pushnumber(d);
+}
 
-static void math_abs (void)
-{
-  double d = luaL_check_number(1);
-  if (d < 0) d = -d;
-  lua_pushnumber(d);
+static void math_sin() {
+	lua_pushnumber(sin(TORAD(luaL_check_number(1))));
 }
 
-static void math_sin (void)
-{
-  lua_pushnumber(sin(TORAD(luaL_check_number(1))));
+static void math_cos() {
+	lua_pushnumber(cos(TORAD(luaL_check_number(1))));
 }
 
-static void math_cos (void)
-{
-  lua_pushnumber(cos(TORAD(luaL_check_number(1))));
+static void math_tan() {
+	lua_pushnumber(tan(TORAD(luaL_check_number(1))));
 }
 
-static void math_tan (void)
-{
-  lua_pushnumber(tan(TORAD(luaL_check_number(1))));
+static void math_asin() {
+	lua_pushnumber(FROMRAD(asin(luaL_check_number(1))));
 }
 
-static void math_asin (void)
-{
-  lua_pushnumber(FROMRAD(asin(luaL_check_number(1))));
+static void math_acos() {
+	lua_pushnumber(FROMRAD(acos(luaL_check_number(1))));
 }
 
-static void math_acos (void)
-{
-  lua_pushnumber(FROMRAD(acos(luaL_check_number(1))));
+static void math_atan() {
+	lua_pushnumber(FROMRAD(atan(luaL_check_number(1))));
 }
 
-static void math_atan (void)
-{
-  lua_pushnumber(FROMRAD(atan(luaL_check_number(1))));
+static void math_ceil() {
+	lua_pushnumber(ceil(luaL_check_number(1)));
 }
 
-static void math_ceil (void)
-{
-  lua_pushnumber(ceil(luaL_check_number(1)));
+static void math_floor() {
+	lua_pushnumber(floor(luaL_check_number(1)));
 }
 
-static void math_floor (void)
-{
-  lua_pushnumber(floor(luaL_check_number(1)));
+static void math_mod() {
+	lua_pushnumber(fmod(luaL_check_number(1), luaL_check_number(2)));
 }
 
-static void math_mod (void)
-{
-  lua_pushnumber(fmod(luaL_check_number(1), luaL_check_number(2)));
+static void math_sqrt() {
+	lua_pushnumber(sqrt(luaL_check_number(1)));
 }
 
-static void math_sqrt (void)
-{
-  lua_pushnumber(sqrt(luaL_check_number(1)));
+static void math_pow() {
+	lua_pushnumber(pow(luaL_check_number(1), luaL_check_number(2)));
 }
 
-static void math_pow (void)
-{
-  lua_pushnumber(pow(luaL_check_number(1), luaL_check_number(2)));
+static void math_deg() {
+	lua_pushnumber(luaL_check_number(1) * (180.0/LOCAL_PI));
 }
 
-static void math_deg (void)
-{
-  lua_pushnumber(luaL_check_number(1)*(180.0/LOCAL_PI));
+static void math_rad() {
+	lua_pushnumber(luaL_check_number(1) * (LOCAL_PI / 180.0));
 }
-  
-static void math_rad (void)
-{
-  lua_pushnumber(luaL_check_number(1)*(LOCAL_PI/180.0));
+
+static void math_min() {
+	int32 i = 1;
+	double dmin = luaL_check_number(i);
+	while (lua_getparam(++i) != LUA_NOOBJECT) {
+		double d = luaL_check_number(i);
+		if (d < dmin)
+			dmin = d;
+	}
+	lua_pushnumber(dmin);
 }
-    
-static void math_min (void)
-{
-  int32 i = 1;
-  double dmin = luaL_check_number(i);
-  while (lua_getparam(++i) != LUA_NOOBJECT) {
-    double d = luaL_check_number(i);
-    if (d < dmin)
-      dmin = d;
-  }
-  lua_pushnumber(dmin);
-}
 
-static void math_max (void)
-{
-  int32 i = 1;
-  double dmax = luaL_check_number(i);
-  while (lua_getparam(++i) != LUA_NOOBJECT) {
-    double d = luaL_check_number(i);
-    if (d > dmax)
-      dmax = d;
-  }
-  lua_pushnumber(dmax);
+static void math_max() {
+	int32 i = 1;
+	double dmax = luaL_check_number(i);
+	while (lua_getparam(++i) != LUA_NOOBJECT) {
+		double d = luaL_check_number(i);
+		if (d > dmax)
+			dmax = d;
+	}
+	lua_pushnumber(dmax);
 }
 
-static void math_random (void)
-{
-  /* the '%' is needed because on some systems (SunOS!) "rand()" may */
-  /* return a value bigger than RAND_MAX... */
-  double r = (double)(rand()%RAND_MAX) / (double)RAND_MAX;
-  double l = luaL_opt_number(1, 0);
-  if (l == 0)
-    lua_pushnumber(r);
-  else
-    lua_pushnumber((int32)(r*l)+1);
+static void math_random() {
+	double r = (double)(rand() % RAND_MAX) / (double)RAND_MAX;
+	double l = luaL_opt_number(1, 0);
+	if (l == 0)
+		lua_pushnumber(r);
+	else
+		lua_pushnumber((int32)(r * l) + 1);
 }
 
-static void math_randomseed (void)
-{
-  srand((unsigned int)luaL_check_number(1));
+static void math_randomseed() {
+	srand((unsigned int)luaL_check_number(1));
 }
 
-
 static struct luaL_reg mathlib[] = {
-{"abs",   math_abs},
-{"sin",   math_sin},
-{"cos",   math_cos},
-{"tan",   math_tan},
-{"asin",  math_asin},
-{"acos",  math_acos},
-{"atan",  math_atan},
-{"ceil",  math_ceil},
-{"floor", math_floor},
-{"mod",   math_mod},
-{"sqrt",  math_sqrt},
-{"min",   math_min},
-{"max",   math_max},
-{"deg",   math_deg},
-{"rad",   math_rad},
-{"random",     math_random},
-{"randomseed", math_randomseed}
+	{ "abs",	math_abs},
+	{ "sin",	math_sin},
+	{ "cos",	math_cos},
+	{ "tan",	math_tan},
+	{ "asin",	math_asin},
+	{ "acos",	math_acos},
+	{ "atan",	math_atan},
+	{ "ceil",	math_ceil},
+	{ "floor",	math_floor},
+	{ "mod",	math_mod},
+	{ "sqrt",	math_sqrt},
+	{ "min",	math_min},
+	{ "max",	math_max},
+	{ "deg",	math_deg},
+	{ "rad",	math_rad},
+	{ "random",		math_random},
+	{ "randomseed",	math_randomseed}
 };
 
 static luaL_reg powFunc[] = {
-{"math_pow",   math_pow}
+	{ "math_pow",	math_pow }
 };
 
 /*
 ** Open math library
 */
-void lua_mathlibopen (void)
-{
-  luaL_openlib(mathlib, (sizeof(mathlib)/sizeof(mathlib[0])));
-  luaL_addlibtolist(powFunc, (sizeof(powFunc)/sizeof(powFunc[0])));
-  lua_pushstring("deg"); lua_setglobal("_TRIGMODE");
-  lua_pushcfunction(math_pow);
-  lua_pushnumber(0);  /* to get its tag */
-  lua_settagmethod(lua_tag(lua_pop()), "pow");
-  lua_pushnumber(LOCAL_PI); lua_setglobal("PI");
+void lua_mathlibopen() {
+	luaL_openlib(mathlib, (sizeof(mathlib) / sizeof(mathlib[0])));
+	luaL_addlibtolist(powFunc, (sizeof(powFunc) / sizeof(powFunc[0])));
+	lua_pushstring("deg");
+	lua_setglobal("_TRIGMODE");
+	lua_pushcfunction(math_pow);
+	lua_pushnumber(0);  // to get its tag
+	lua_settagmethod(lua_tag(lua_pop()), "pow");
+	lua_pushnumber(LOCAL_PI);
+	lua_setglobal("PI");
 }
 

Modified: residual/trunk/engine/lua/lmem.cpp
===================================================================
--- residual/trunk/engine/lua/lmem.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lmem.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -5,105 +5,84 @@
 */
 
 
+#include "engine/lua/lmem.h"
+#include "engine/lua/lstate.h"
+#include "engine/lua/lua.h"
 
-#include "lmem.h"
-#include "lstate.h"
-#include "lua.h"
-
-
-
-int32 luaM_growaux (void **block, int32 nelems, int32 size,
-                       const char *errormsg, int32 limit)
-{
-  if (nelems >= limit)
-    lua_error(errormsg);
-  nelems = (nelems == 0) ? 32 : nelems*2;
-  if (nelems > limit)
-    nelems = limit;
-  *block = luaM_realloc(*block, nelems*size);
-  return (int32)nelems;
+int32 luaM_growaux(void **block, int32 nelems, int32 size, const char *errormsg, int32 limit) {
+	if (nelems >= limit)
+		lua_error(errormsg);
+	nelems = (nelems == 0) ? 32 : nelems * 2;
+	if (nelems > limit)
+		nelems = limit;
+	*block = luaM_realloc(*block, nelems * size);
+	return (int32)nelems;
 }
 
+#ifndef LUA_DEBUG
 
-
-#ifndef DEBUG
-
 /*
 ** generic allocation routine.
 ** real ANSI systems do not need some of these tests,
 ** since realloc(NULL, s)==malloc(s) and realloc(b, 0)==free(b).
 ** But some systems (e.g. Sun OS) are not that ANSI...
 */
-void *luaM_realloc (void *block, int32 size)
-{
-  if (size == 0) {
-    if (block) {
-      free(block);
-    }
-    return NULL;
-  }
-  block = block ? realloc(block, size) : malloc(size);
-  if (block == NULL)
-    lua_error(memEM);
-  return block;
+void *luaM_realloc(void *block, int32 size) {
+	if (size == 0) {
+		if (block) {
+			free(block);
+		}
+		return NULL;
+	}
+	block = block ? realloc(block, size) : malloc(size);
+	if (!block)
+		lua_error(memEM);
+	return block;
 }
 
-
-
 #else
-/* DEBUG */
+/* LUA_DEBUG */
 
-#include <string.h>
-
-
 #define HEADER	(sizeof(double))
-
 #define MARK    55
 
 int32 numblocks = 0;
 int32 totalmem = 0;
 
-
-static void *checkblock (void *block)
-{
-  int32 *b = (uint32 *)((char *)block - HEADER);
-  int32 size = *b;
-  LUA_ASSERT(*(((char *)b)+size+HEADER) == MARK, 
-             "corrupted block");
-  numblocks--;
-  totalmem -= size;
-  return b;
+static void *checkblock(void *block) {
+	int32 *b = (uint32 *)((char *)block - HEADER);
+	int32 size = *b;
+	LUA_ASSERT(*(((char *)b) + size + HEADER) == MARK, "corrupted block");
+	numblocks--;
+	totalmem -= size;
+	return b;
 }
 
-
-void *luaM_realloc (void *block, int32 size)
-{
-  int32 realsize = HEADER+size+1;
-  if (realsize != (size_t)realsize)
-    lua_error("Allocation Error: Block too big");
-  if (size == 0) {  /* ANSI dosen't need this, but some machines... */
-    if (block) {
-      int32 *b = (int32 *)((char *)block - HEADER);
-      memset(block, -1, *b);  /* erase block */
-      block = checkblock(block);
-      free(block);
-    }
-    return NULL;
-  }
-  if (block) {
-    block = checkblock(block);
-    block = (int32 *)realloc(block, realsize);
-  }
-  else
-    block = (int32 *)malloc(realsize);
-  if (block == NULL)
-    lua_error(memEM);
-  totalmem += size;
-  numblocks++;
-  *(int32 *)block = size;
-  *(((char *)block)+size+HEADER) = MARK;
-  return (int32 *)((char *)block+HEADER);
+void *luaM_realloc(void *block, int32 size) {
+	int32 realsize = HEADER + size + 1;
+	if (realsize != (size_t)realsize)
+		lua_error("Allocation Error: Block too big");
+	if (size == 0) {  // ANSI dosen't need this, but some machines...
+		if (block) {
+			int32 *b = (int32 *)((char *)block - HEADER);
+			memset(block, -1, *b);  // erase block
+			block = checkblock(block);
+			free(block);
+		}
+		return NULL;
+	}
+	if (block) {
+		block = checkblock(block);
+		block = (int32 *)realloc(block, realsize);
+	} else
+		block = (int32 *)malloc(realsize);
+	if (!block)
+		lua_error(memEM);
+	totalmem += size;
+	numblocks++;
+	*(int32 *)block = size;
+	*(((char *)block) + size + HEADER) = MARK;
+	return (int32 *)((char *)block + HEADER);
 }
 
-
 #endif

Modified: residual/trunk/engine/lua/lmem.h
===================================================================
--- residual/trunk/engine/lua/lmem.h	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lmem.h	2008-07-29 14:57:13 UTC (rev 33411)
@@ -9,33 +9,24 @@
 
 #include "common/sys.h"
 
+// memory error messages
+#define codeEM		"code size overflow"
+#define constantEM	"constant table overflow"
+#define refEM		"reference table overflow"
+#define tableEM		"table overflow"
+#define memEM		"not enough memory"
 
-#ifndef NULL
-#define NULL 0
-#endif
-
-
-/* memory error messages */
-#define codeEM   "code size overflow"
-#define constantEM   "constant table overflow"
-#define refEM   "reference table overflow"
-#define tableEM  "table overflow"
-#define memEM "not enough memory"
-
 void *luaM_realloc (void *oldblock, int32 size);
-int32 luaM_growaux (void **block, int32 nelems, int32 size,
-                       const char *errormsg, int32 limit);
+int32 luaM_growaux (void **block, int32 nelems, int32 size, const char *errormsg, int32 limit);
 
-#define luaM_free(b)	free((b))
-#define luaM_malloc(t)	malloc((t))
-#define luaM_new(t)          ((t *)malloc(sizeof(t)))
-#define luaM_newvector(n,t)  ((t *)malloc((n)*sizeof(t)))
-#define luaM_growvector(old,n,t,e,l) \
-          (luaM_growaux((void**)old,n,sizeof(t),e,l))
-#define luaM_reallocvector(v,n,t) ((t *)realloc(v,(n)*sizeof(t)))
+#define luaM_free(b)						free((b))
+#define luaM_malloc(t)						malloc((t))
+#define luaM_new(t)							((t *)malloc(sizeof(t)))
+#define luaM_newvector(n, t)				((t *)malloc((n) * sizeof(t)))
+#define luaM_growvector(old, n, t, e, l)	(luaM_growaux((void**)old, n, sizeof(t), e, l))
+#define luaM_reallocvector(v, n, t)			((t *)realloc(v,(n) * sizeof(t)))
 
-
-#ifdef DEBUG
+#ifdef LUA_DEBUG
 extern int32 numblocks;
 extern int32 totalmem;
 #endif

Modified: residual/trunk/engine/lua/lobject.cpp
===================================================================
--- residual/trunk/engine/lua/lobject.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lobject.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -4,61 +4,63 @@
 ** See Copyright Notice in lua.h
 */
 
-#include "lobject.h"
-#include "lua.h"
+#include "engine/lua/lobject.h"
+#include "engine/lua/lua.h"
 
-
-const char *luaO_typenames[] = { /* ORDER LUA_T */
-    "userdata", "number", "string", "table", "function", "function", "task",
-    "nil", "function", "mark", "mark", "mark", "line", NULL
+const char *luaO_typenames[] = { // ORDER LUA_T
+	"userdata", "number", "string", "table", "function", "function", "task",
+	"nil", "function", "mark", "mark", "mark", "line", NULL
 };
 
+TObject luaO_nilobject = { LUA_T_NIL, { NULL } };
 
-TObject luaO_nilobject = {LUA_T_NIL, {NULL}};
 
+// hash dimensions values
+static int32 dimensions[] = {
+	5, 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421,
+	12853, 25717, 51437, 102811, 205619, 411233, 822433,
+	1644817, 3289613, 6579211, 13158023, MAX_INT
+};
 
-
-/* hash dimensions values */
-static int32 dimensions[] =
- {5, 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421,
-  12853, 25717, 51437, 102811, 205619, 411233, 822433,
-  1644817, 3289613, 6579211, 13158023, MAX_INT};
-
-
-int32 luaO_redimension (int32 oldsize)
-{
-  int32 i;
-  for (i=0; dimensions[i]<MAX_INT; i++) {
-    if (dimensions[i] > oldsize)
-      return dimensions[i];
-  }
-  lua_error("table overflow");
-  return 0;  /* to avoid warnings */
+int32 luaO_redimension(int32 oldsize) {
+	int32 i;
+	for (i = 0; dimensions[i] < MAX_INT; i++) {
+		if (dimensions[i] > oldsize)
+			return dimensions[i];
+	}
+	lua_error("table overflow");
+	return 0;  // to avoid warnings
 }
 
-
-int32 luaO_equalObj (TObject *t1, TObject *t2)
-{
-  if (ttype(t1) != ttype(t2)) return 0;
-  switch (ttype(t1)) {
-    case LUA_T_NIL: return 1;
-    case LUA_T_NUMBER: return nvalue(t1) == nvalue(t2);
-    case LUA_T_STRING: case LUA_T_USERDATA: return svalue(t1) == svalue(t2);
-    case LUA_T_ARRAY: return avalue(t1) == avalue(t2);
-    case LUA_T_PROTO: return tfvalue(t1)  == tfvalue(t2);
-    case LUA_T_CPROTO: return fvalue(t1)  == fvalue(t2);
-    case LUA_T_CLOSURE: return t1->value.cl == t2->value.cl;
-    case LUA_T_TASK: return nvalue(t1) == nvalue(t2);
-    default:
-     LUA_INTERNALERROR("invalid type");
-     return 0; /* UNREACHABLE */
-  }
+int32 luaO_equalObj(TObject *t1, TObject *t2) {
+	if (ttype(t1) != ttype(t2))
+		return 0;
+	switch (ttype(t1)) {
+	case LUA_T_NIL:
+		return 1;
+	case LUA_T_NUMBER: return
+						   nvalue(t1) == nvalue(t2);
+	case LUA_T_STRING:
+	case LUA_T_USERDATA:
+		return svalue(t1) == svalue(t2);
+	case LUA_T_ARRAY:
+		return avalue(t1) == avalue(t2);
+	case LUA_T_PROTO:
+		return tfvalue(t1)  == tfvalue(t2);
+	case LUA_T_CPROTO:
+		return fvalue(t1)  == fvalue(t2);
+	case LUA_T_CLOSURE:
+		return t1->value.cl == t2->value.cl;
+	case LUA_T_TASK:
+		return nvalue(t1) == nvalue(t2);
+	default:
+		LUA_INTERNALERROR("invalid type");
+		return 0; // UNREACHABLE
+	}
 }
 
-
-void luaO_insertlist (GCnode *root, GCnode *node)
-{
-  node->next = root->next;
-  root->next = node;
-  node->marked = 0;
+void luaO_insertlist(GCnode *root, GCnode *node) {
+	node->next = root->next;
+	root->next = node;
+	node->marked = 0;
 }

Modified: residual/trunk/engine/lua/lobject.h
===================================================================
--- residual/trunk/engine/lua/lobject.h	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lobject.h	2008-07-29 14:57:13 UTC (rev 33411)
@@ -7,21 +7,17 @@
 #ifndef lobject_h
 #define lobject_h
 
+#include "engine/lua/lua.h"
 
-#include "lua.h"
-
-
-#ifdef DEBUG
-#include "lauxlib.h"
-#define LUA_INTERNALERROR(s)	\
-	luaL_verror("INTERNAL ERROR - %s [%s:%d]",(s),__FILE__,__LINE__)
-#define LUA_ASSERT(c,s) { if (!(c)) LUA_INTERNALERROR(s); }
+#ifdef LUA_DEBUG
+#include "engine/lua/lauxlib.h"
+#define LUA_INTERNALERROR(s)	luaL_verror("INTERNAL ERROR - %s [%s:%d]", (s), __FILE__, __LINE__)
+#define LUA_ASSERT(c, s)			{ if (!(c)) LUA_INTERNALERROR(s); }
 #else
-#define LUA_INTERNALERROR(s)  /* empty */
-#define LUA_ASSERT(c,s)  /* empty */
+#define LUA_INTERNALERROR(s)	// empty
+#define LUA_ASSERT(c, s)			// empty
 #endif
 
-
 /*
 ** "real" is the type "number" of Lua
 ** GREP LUA_NUMBER to change that
@@ -37,115 +33,97 @@
 
 typedef LUA_NUM_TYPE real;
 
-#define Byte lua_Byte	/* some systems have Byte as a predefined type */
-typedef byte Byte;  /* unsigned 8 bits */
+#define MAX_INT			(2147483647 - 2)  // maximum value of an int (-2 for safety)
+#define MAX_WORD		65534
 
 
-#define MAX_INT   (2147483647-2)  /* maximum value of an int (-2 for safety) */
-#define MAX_WORD        65534
-
-typedef unsigned long IntPoint; /* unsigned with same size as a pointer (for hashing) */
-
-
 /*
 ** Lua TYPES
 ** WARNING: if you change the order of this enumeration,
 ** grep "ORDER LUA_T"
 */
 typedef enum {
-  LUA_T_USERDATA =  0,  /* tag default for userdata */
-  LUA_T_NUMBER   = -1,  /* fixed tag for numbers */
-  LUA_T_STRING   = -2,  /* fixed tag for strings */
-  LUA_T_ARRAY    = -3,  /* tag default for tables (or arrays) */
-  LUA_T_PROTO    = -4,  /* fixed tag for functions */
-  LUA_T_CPROTO   = -5,  /* fixed tag for Cfunctions */
-  LUA_T_TASK     = -6,  /* task tag */
-  LUA_T_NIL      = -7,  /* last "pre-defined" tag */
-  LUA_T_CLOSURE  = -8,
-  LUA_T_CLMARK   = -9,  /* mark for closures */
-  LUA_T_PMARK    = -10,  /* mark for Lua prototypes */
-  LUA_T_CMARK    = -11, /* mark for C prototypes */
-  LUA_T_LINE     = -12
+	LUA_T_USERDATA =  0,  // tag default for userdata
+	LUA_T_NUMBER   = -1,  // fixed tag for numbers
+	LUA_T_STRING   = -2,  // fixed tag for strings
+	LUA_T_ARRAY    = -3,  // tag default for tables (or arrays)
+	LUA_T_PROTO    = -4,  // fixed tag for functions
+	LUA_T_CPROTO   = -5,  // fixed tag for Cfunctions
+	LUA_T_TASK     = -6,  // task tag
+	LUA_T_NIL      = -7,  // last "pre-defined" tag
+	LUA_T_CLOSURE  = -8,
+	LUA_T_CLMARK   = -9,  // mark for closures
+	LUA_T_PMARK    = -10, // mark for Lua prototypes
+	LUA_T_CMARK    = -11, // mark for C prototypes
+	LUA_T_LINE     = -12
 } lua_Type;
 
 #define NUM_TYPES 12
 #define NUM_TAGS  8
 
-
 typedef union {
-  lua_CFunction f;  /* LUA_T_CPROTO, LUA_T_CMARK */
-  real n;  /* LUA_T_NUMBER */
-  struct TaggedString *ts;  /* LUA_T_STRING, LUA_T_USERDATA */
-  struct TProtoFunc *tf;  /* LUA_T_PROTO, LUA_T_PMARK */
-  struct Closure *cl;  /* LUA_T_CLOSURE, LUA_T_CLMARK */
-  struct Hash *a;  /* LUA_T_ARRAY */
-  int32 i;  /* LUA_T_LINE */
+	lua_CFunction f;  // LUA_T_CPROTO, LUA_T_CMARK
+	real n;  // LUA_T_NUMBER
+	struct TaggedString *ts;  // LUA_T_STRING, LUA_T_USERDATA
+	struct TProtoFunc *tf;  // LUA_T_PROTO, LUA_T_PMARK
+	struct Closure *cl;  // LUA_T_CLOSURE, LUA_T_CLMARK
+	struct Hash *a;  // LUA_T_ARRAY
+	int32 i;  // LUA_T_LINE
 } Value;
 
-
 typedef struct TObject {
-  lua_Type ttype;
-  Value value;
+	lua_Type ttype;
+	Value value;
 } TObject;
 
-
-
 /*
 ** generic header for garbage collector lists
 */
 typedef struct GCnode {
-  struct GCnode *next;
-  int32 marked;
+	struct GCnode *next;
+	int32 marked;
 } GCnode;
 
-
 /*
 ** String headers for string table
 */
 
 typedef struct TaggedString {
-  GCnode head;
-  unsigned long hash;
-  int32 constindex;  /* hint to reuse constants (= -1 if this is a userdata) */
-  union {
-    struct {
-      TObject globalval;
-      int32 len;  /* if this is a string, here is its length */
-    } s;
-    struct {
-      int32 tag;
-      void *v;  /* if this is a userdata, here is its value */
-    } d;
-  } u;
-  char str[1];   /* \0 byte already reserved */
+	GCnode head;
+	unsigned long hash;
+	int32 constindex;  // hint to reuse constants (= -1 if this is a userdata)
+	union {
+		struct {
+			TObject globalval;
+			int32 len;  // if this is a string, here is its length
+		} s;
+		struct {
+			int32 tag;
+			void *v;  // if this is a userdata, here is its value
+		} d;
+	} u;
+	char str[1];   // \0 byte already reserved
 } TaggedString;
 
-
-
-
 /*
 ** Function Prototypes
 */
 typedef struct TProtoFunc {
-  GCnode head;
-  struct TObject *consts;
-  int32 nconsts;
-  Byte *code;  /* ends with opcode ENDCODE */
-  int32 lineDefined;
-  TaggedString  *fileName;
-  struct LocVar *locvars;  /* ends with line = -1 */
+	GCnode head;
+	struct TObject *consts;
+	int32 nconsts;
+	byte *code;  // ends with opcode ENDCODE
+	int32 lineDefined;
+	TaggedString  *fileName;
+	struct LocVar *locvars;  // ends with line = -1
 } TProtoFunc;
 
 typedef struct LocVar {
-  TaggedString *varname;           /* NULL signals end of scope */
-  int32 line;
+	TaggedString *varname;           // NULL signals end of scope
+	int32 line;
 } LocVar;
 
-
-
-
-
-/* Macros to access structure members */
+// Macros to access structure members
 #define ttype(o)        ((o)->ttype)
 #define nvalue(o)       ((o)->value.n)
 #define svalue(o)       ((o)->value.ts->str)
@@ -153,8 +131,7 @@
 #define clvalue(o)      ((o)->value.cl)
 #define avalue(o)       ((o)->value.a)
 #define fvalue(o)       ((o)->value.f)
-#define tfvalue(o)	((o)->value.tf)
-
+#define tfvalue(o)		((o)->value.tf)
 #define protovalue(o)	((o)->value.cl->consts)
 
 
@@ -162,36 +139,32 @@
 ** Closures
 */
 typedef struct Closure {
-  GCnode head;
-  int32 nelems;  /* not included the first one (always the prototype) */
-  TObject consts[1];  /* at least one for prototype */
+	GCnode head;
+	int32 nelems;  // not included the first one (always the prototype)
+	TObject consts[1];  // at least one for prototype
 } Closure;
 
-
-
 typedef struct node {
-  TObject ref;
-  TObject val;
+	TObject ref;
+	TObject val;
 } Node;
 
 typedef struct Hash {
-  GCnode head;
-  Node *node;
-  int32 nhash;
-  int32 nuse;
-  int32 htag;
+	GCnode head;
+	Node *node;
+	int32 nhash;
+	int32 nuse;
+	int32 htag;
 } Hash;
 
-
 extern const char *luaO_typenames[];
-
 extern TObject luaO_nilobject;
 
-int32 luaO_equalObj (TObject *t1, TObject *t2);
-int32 luaO_redimension (int32 oldsize);
-void luaO_insertlist (GCnode *root, GCnode *node);
+int32 luaO_equalObj(TObject *t1, TObject *t2);
+int32 luaO_redimension(int32 oldsize);
+void luaO_insertlist(GCnode *root, GCnode *node);
 
-#define luaO_memup(d,s,n)	memmove(d,s,n)
-#define luaO_memdown(d,s,n)	memmove(d,s,n)
+#define luaO_memup(d, s, n)		memmove(d, s, n)
+#define luaO_memdown(d, s, n)	memmove(d, s, n)
 
 #endif

Modified: residual/trunk/engine/lua/lopcodes.h
===================================================================
--- residual/trunk/engine/lua/lopcodes.h	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lopcodes.h	2008-07-29 14:57:13 UTC (rev 33411)
@@ -7,176 +7,171 @@
 #ifndef lopcodes_h
 #define lopcodes_h
 
-
 /*
 ** NOTICE: variants of the same opcode must be consecutive: First, those
 ** with byte parameter, then with built-in parameters, and last with
 ** word parameter.
 */
 
-
 typedef enum {
-/* name          parm    before          after           side effect
------------------------------------------------------------------------------*/
-ENDCODE,/*	-	-		-  */
+//	name				parm    before          after			side effect
+//-----------------------------------------------------------------------------
+	ENDCODE,		//	-		-				-  
 
-PUSHNIL,/*	b	-		nil_0...nil_b  */
-PUSHNIL0,/*	-	-		nil  */
+	PUSHNIL,		//	b		-				nil_0...nil_b  
+	PUSHNIL0,		//	-		-				nil  
 
-PUSHNUMBER,/*	b	-		(float)b  */
-PUSHNUMBER0,/*	-	-		0.0  */
-PUSHNUMBER1,/*	-	-		1.0  */
-PUSHNUMBER2,/*	-	-		2.0  */
-PUSHNUMBERW,/*	w	-		(float)w  */
+	PUSHNUMBER,		//	b		-				(float)b  
+	PUSHNUMBER0,	//	-		-				0.0  
+	PUSHNUMBER1,	//	-		-				1.0  
+	PUSHNUMBER2,	//	-		-				2.0  
+	PUSHNUMBERW,	//	w		-				(float)w  
 
-PUSHCONSTANT,/*	b	-		CNST[b] */
-PUSHCONSTANT0,/*-	-		CNST[0] */
-PUSHCONSTANT1,/*-	-		CNST[1] */
-PUSHCONSTANT2,/*-	-		CNST[2] */
-PUSHCONSTANT3,/*-	-		CNST[3] */
-PUSHCONSTANT4,/*-	-		CNST[4] */
-PUSHCONSTANT5,/*-	-		CNST[5] */
-PUSHCONSTANT6,/*-	-		CNST[6] */
-PUSHCONSTANT7,/*-	-		CNST[7] */
-PUSHCONSTANTW,/*w	-		CNST[w] */
+	PUSHCONSTANT,	//	b		-				CNST[b] 
+	PUSHCONSTANT0,	//	-		-				CNST[0] 
+	PUSHCONSTANT1,	//	-		-				CNST[1] 
+	PUSHCONSTANT2,	//	-		-				CNST[2] 
+	PUSHCONSTANT3,	//	-		-				CNST[3] 
+	PUSHCONSTANT4,	//	-		-				CNST[4] 
+	PUSHCONSTANT5,	//	-		-				CNST[5] 
+	PUSHCONSTANT6,	//	-		-				CNST[6] 
+	PUSHCONSTANT7,	//	-		-				CNST[7] 
+	PUSHCONSTANTW,	//	w		-				CNST[w] 
 
-PUSHUPVALUE,/*	b	-		Closure[b] */
-PUSHUPVALUE0,/*	-	-		Closure[0] */
-PUSHUPVALUE1,/*	-	-		Closure[1] */
+	PUSHUPVALUE,	//	b		-				Closure[b] 
+	PUSHUPVALUE0,	//	-		-				Closure[0] 
+	PUSHUPVALUE1,	//	-		-				Closure[1] 
 
-PUSHLOCAL,/*	b	-		LOC[b]  */
-PUSHLOCAL0,/*	-	-		LOC[0]  */
-PUSHLOCAL1,/*	-	-		LOC[1]  */
-PUSHLOCAL2,/*	-	-		LOC[2]  */
-PUSHLOCAL3,/*	-	-		LOC[3]  */
-PUSHLOCAL4,/*	-	-		LOC[4]  */
-PUSHLOCAL5,/*	-	-		LOC[5]  */
-PUSHLOCAL6,/*	-	-		LOC[6]  */
-PUSHLOCAL7,/*	-	-		LOC[7]  */
+	PUSHLOCAL,		//	b		-				LOC[b]  
+	PUSHLOCAL0,		//	-		-				LOC[0]  
+	PUSHLOCAL1,		//	-		-				LOC[1]  
+	PUSHLOCAL2,		//	-		-				LOC[2]  
+	PUSHLOCAL3,		//	-		-				LOC[3]  
+	PUSHLOCAL4,		//	-		-				LOC[4]  
+	PUSHLOCAL5,		//	-		-				LOC[5]  
+	PUSHLOCAL6,		//	-		-				LOC[6]  
+	PUSHLOCAL7,		//	-		-				LOC[7]  
 
-GETGLOBAL,/*	b 	-		VAR[CNST[b]]  */
-GETGLOBAL0,/*	-	-		VAR[CNST[0]]  */
-GETGLOBAL1,/*	-	-		VAR[CNST[1]]  */
-GETGLOBAL2,/*	-	-		VAR[CNST[2]]  */
-GETGLOBAL3,/*	-	-		VAR[CNST[3]]  */
-GETGLOBAL4,/*	-	-		VAR[CNST[4]]  */
-GETGLOBAL5,/*	-	-		VAR[CNST[5]]  */
-GETGLOBAL6,/*	-	-		VAR[CNST[6]]  */
-GETGLOBAL7,/*	-	-		VAR[CNST[7]]  */
-GETGLOBALW,/*	w	-		VAR[CNST[w]]  */
+	GETGLOBAL,		//	b 		-				VAR[CNST[b]]  
+	GETGLOBAL0,		//	-		-				VAR[CNST[0]]  
+	GETGLOBAL1,		//	-		-				VAR[CNST[1]]  
+	GETGLOBAL2,		//	-		-				VAR[CNST[2]]  
+	GETGLOBAL3,		//	-		-				VAR[CNST[3]]  
+	GETGLOBAL4,		//	-		-				VAR[CNST[4]]  
+	GETGLOBAL5,		//	-		-				VAR[CNST[5]]  
+	GETGLOBAL6,		//	-		-				VAR[CNST[6]]  
+	GETGLOBAL7,		//	-		-				VAR[CNST[7]]  
+	GETGLOBALW,		//	w		-				VAR[CNST[w]]  
 
-GETTABLE,/*	-	i t		t[i]  */
+	GETTABLE,		//	-		i t				t[i]  
 
-GETDOTTED,/*	b	t		t[CNST[b]]  */
-GETDOTTED0,/*	-	t		t[CNST[0]]  */
-GETDOTTED1,/*	-	t		t[CNST[1]]  */
-GETDOTTED2,/*	-	t		t[CNST[2]]  */
-GETDOTTED3,/*	-	t		t[CNST[3]]  */
-GETDOTTED4,/*	-	t		t[CNST[4]]  */
-GETDOTTED5,/*	-	t		t[CNST[5]]  */
-GETDOTTED6,/*	-	t		t[CNST[6]]  */
-GETDOTTED7,/*	-	t		t[CNST[7]]  */
-GETDOTTEDW,/*	w	t		t[CNST[w]]  */
+	GETDOTTED,		//	b		t				t[CNST[b]]  
+	GETDOTTED0,		//	-		t				t[CNST[0]]  
+	GETDOTTED1,		//	-		t				t[CNST[1]]  
+	GETDOTTED2,		//	-		t				t[CNST[2]]  
+	GETDOTTED3,		//	-		t				t[CNST[3]]  
+	GETDOTTED4,		//	-		t				t[CNST[4]]  
+	GETDOTTED5,		//	-		t				t[CNST[5]]  
+	GETDOTTED6,		//	-		t				t[CNST[6]]  
+	GETDOTTED7,		//	-		t				t[CNST[7]]  
+	GETDOTTEDW,		//	w		t				t[CNST[w]]  
 
-PUSHSELF,/*	b	t		t t[CNST[b]]  */
-PUSHSELF0,/*	-	t		t t[CNST[0]]  */
-PUSHSELF1,/*	-	t		t t[CNST[1]]  */
-PUSHSELF2,/*	-	t		t t[CNST[2]]  */
-PUSHSELF3,/*	-	t		t t[CNST[3]]  */
-PUSHSELF4,/*	-	t		t t[CNST[4]]  */
-PUSHSELF5,/*	-	t		t t[CNST[5]]  */
-PUSHSELF6,/*	-	t		t t[CNST[6]]  */
-PUSHSELF7,/*	-	t		t t[CNST[7]]  */
-PUSHSELFW,/*	w	t		t t[CNST[w]]  */
+	PUSHSELF,		//	b		t				t t[CNST[b]]  
+	PUSHSELF0,		//	-		t				t t[CNST[0]]  
+	PUSHSELF1,		//	-		t				t t[CNST[1]]  
+	PUSHSELF2,		//	-		t				t t[CNST[2]]  
+	PUSHSELF3,		//	-		t				t t[CNST[3]]  
+	PUSHSELF4,		//	-		t				t t[CNST[4]]  
+	PUSHSELF5,		//	-		t				t t[CNST[5]]  
+	PUSHSELF6,		//	-		t				t t[CNST[6]]  
+	PUSHSELF7,		//	-		t				t t[CNST[7]]  
+	PUSHSELFW,		//	w		t				t t[CNST[w]]  
 
-CREATEARRAY,/*	b	-		newarray(size = b)  */
-CREATEARRAY0,/*	-	-		newarray(size = 0)  */
-CREATEARRAY1,/*	-	-		newarray(size = 1)  */
-CREATEARRAYW,/*	w	-		newarray(size = w)  */
+	CREATEARRAY,	//	b		-				newarray(size = b)  
+	CREATEARRAY0,	//	-		-				newarray(size = 0)  
+	CREATEARRAY1,	//	-		-				newarray(size = 1)  
+	CREATEARRAYW,	//	w		-				newarray(size = w)  
 
-SETLOCAL,/*	b	x		-		LOC[b]=x  */
-SETLOCAL0,/*	-	x		-		LOC[0]=x  */
-SETLOCAL1,/*	-	x		-		LOC[1]=x  */
-SETLOCAL2,/*	-	x		-		LOC[2]=x  */
-SETLOCAL3,/*	-	x		-		LOC[3]=x  */
-SETLOCAL4,/*	-	x		-		LOC[4]=x  */
-SETLOCAL5,/*	-	x		-		LOC[5]=x  */
-SETLOCAL6,/*	-	x		-		LOC[6]=x  */
-SETLOCAL7,/*	-	x		-		LOC[7]=x  */
+	SETLOCAL,		//	b		x				-				LOC[b]=x  
+	SETLOCAL0,		//	-		x				-				LOC[0]=x  
+	SETLOCAL1,		//	-		x				-				LOC[1]=x  
+	SETLOCAL2,		//	-		x				-				LOC[2]=x  
+	SETLOCAL3,		//	-		x				-				LOC[3]=x  
+	SETLOCAL4,		//	-		x				-				LOC[4]=x  
+	SETLOCAL5,		//	-		x				-				LOC[5]=x  
+	SETLOCAL6,		//	-		x				-				LOC[6]=x  
+	SETLOCAL7,		//	-		x				-				LOC[7]=x  
 
-SETGLOBAL,/*	b	x		-		VAR[CNST[b]]=x  */
-SETGLOBAL0,/*	-	x		-		VAR[CNST[0]]=x  */
-SETGLOBAL1,/*	-	x		-		VAR[CNST[1]]=x  */
-SETGLOBAL2,/*	-	x		-		VAR[CNST[2]]=x  */
-SETGLOBAL3,/*	-	x		-		VAR[CNST[3]]=x  */
-SETGLOBAL4,/*	-	x		-		VAR[CNST[4]]=x  */
-SETGLOBAL5,/*	-	x		-		VAR[CNST[5]]=x  */
-SETGLOBAL6,/*	-	x		-		VAR[CNST[6]]=x  */
-SETGLOBAL7,/*	-	x		-		VAR[CNST[7]]=x  */
-SETGLOBALW,/*	w	x		-		VAR[CNST[w]]=x  */
+	SETGLOBAL,		//	b		x				-				VAR[CNST[b]]=x  
+	SETGLOBAL0,		//	-		x				-				VAR[CNST[0]]=x  
+	SETGLOBAL1,		//	-		x				-				VAR[CNST[1]]=x  
+	SETGLOBAL2,		//	-		x				-				VAR[CNST[2]]=x  
+	SETGLOBAL3,		//	-		x				-				VAR[CNST[3]]=x  
+	SETGLOBAL4,		//	-		x				-				VAR[CNST[4]]=x  
+	SETGLOBAL5,		//	-		x				-				VAR[CNST[5]]=x  
+	SETGLOBAL6,		//	-		x				-				VAR[CNST[6]]=x  
+	SETGLOBAL7,		//	-		x				-				VAR[CNST[7]]=x  
+	SETGLOBALW,		//	w		x				-				VAR[CNST[w]]=x  
 
-SETTABLE0,/*	-	v i t		-		t[i]=v  */
+	SETTABLE0,		//	-		vci	t			-				t[i]=v  
 
-SETTABLE,/*	b	v a_b...a_1 i t	a_b...a_1 i t	t[i]=v  */
+	SETTABLE,		//	b		v a_b...a_1 i	t a_b...a_1 i t	t[i]=v  
 
-SETLIST,/*	b c	v_c...v_1 t	-		t[i+b*FPF]=v_i  */
-SETLIST0,/*	b	v_b...v_1 t	-		t[i]=v_i  */
-SETLISTW,/*	w c	v_c...v_1 t	-		t[i+w*FPF]=v_i  */
+	SETLIST,		//	b c		v_c...v_1 t		-				t[i+b*FPF]=v_i  
+	SETLIST0,		//	b		v_b...v_1 t		-				t[i]=v_i  
+	SETLISTW,		//	w c		v_c...v_1 t		-				t[i+w*FPF]=v_i  
 
-SETMAP,/*	b	v_b k_b ...v_0 k_0 t	t	t[k_i]=v_i  */
-SETMAP0,/*	-	v_0 k_0 t		t	t[k_0]=v_0  */
+	SETMAP,			//	b		v_b k_b ...v_0 k_0 t	t		t[k_i]=v_i  
+	SETMAP0,		//	-		v_0 k_0 t		t				t[k_0]=v_0  
 
-EQOP,/*		-	y x		(x==y)? 1 : nil  */
-NEQOP,/*	-	y x		(x~=y)? 1 : nil  */
-LTOP,/*		-	y x		(x<y)? 1 : nil  */
-LEOP,/*		-	y x		(x<y)? 1 : nil  */
-GTOP,/*		-	y x		(x>y)? 1 : nil  */
-GEOP,/*		-	y x		(x>=y)? 1 : nil  */
-ADDOP,/*	-	y x		x+y  */
-SUBOP,/*	-	y x		x-y  */
-MULTOP,/*	-	y x		x*y  */
-DIVOP,/*	-	y x		x/y  */
-POWOP,/*	-	y x		x^y  */
-CONCOP,/*	-	y x		x..y  */
-MINUSOP,/*	-	x		-x  */
-NOTOP,/*	-	x		(x==nil)? 1 : nil  */
+	EQOP,			//	-		y x				(x==y)? 1 : nil  
+	NEQOP,			//	-		y x				(x~=y)? 1 : nil  
+	LTOP,			//	-		y x				(x<y)? 1 : nil  
+	LEOP,			//	-		y x				(x<y)? 1 : nil  
+	GTOP,			//	-		y x				(x>y)? 1 : nil  
+	GEOP,			//	-		y x				(x>=y)? 1 : nil  
+	ADDOP,			//	-		y x				x+y  
+	SUBOP,			//	-		y x				x-y  
+	MULTOP,			//	-		y x				x*y  
+	DIVOP,			//	-		y x				x/y  
+	POWOP,			//	-		y x				x^y  
+	CONCOP,			//	-		y x				x..y  
+	MINUSOP,		//	-		x				-x  
+	NOTOP,			//	-		x				(x==nil)? 1 : nil  
 
-ONTJMP,/*	b	x		(x!=nil)? x : -	(x!=nil)? PC+=b  */
-ONTJMPW,/*	w	x		(x!=nil)? x : -	(x!=nil)? PC+=w  */
-ONFJMP,/*	b	x		(x==nil)? x : -	(x==nil)? PC+=b  */
-ONFJMPW,/*	w	x		(x==nil)? x : -	(x==nil)? PC+=w  */
-JMP,/*		b	-		-		PC+=b  */
-JMPW,/*		w	-		-		PC+=w  */
-IFFJMP,/*	b	x		-		(x==nil)? PC+=b  */
-IFFJMPW,/*	w	x		-		(x==nil)? PC+=w  */
-IFTUPJMP,/*	b	x		-		(x!=nil)? PC-=b  */
-IFTUPJMPW,/*	w	x		-		(x!=nil)? PC-=w  */
-IFFUPJMP,/*	b	x		-		(x==nil)? PC-=b  */
-IFFUPJMPW,/*	w	x		-		(x==nil)? PC-=w  */
+	ONTJMP,			//	b		x				(x!=nil)? x	: -	(x!=nil)? PC+=b  
+	ONTJMPW,		//	w		x				(x!=nil)? x	: -	(x!=nil)? PC+=w  
+	ONFJMP,			//	b		x				(x==nil)? x	: -	(x==nil)? PC+=b  
+	ONFJMPW,		//	w		x				(x==nil)? x	: -	(x==nil)? PC+=w  
+	JMP,			//	b		-				-				PC+=b  
+	JMPW,			//	w		-				-				PC+=w  
+	IFFJMP,			//	b		x				-				(x==nil)? PC+=b  
+	IFFJMPW,		//	w		x				-				(x==nil)? PC+=w  
+	IFTUPJMP,		//	b		x				-				(x!=nil)? PC-=b  
+	IFTUPJMPW,		//	w		x				-				(x!=nil)? PC-=w  
+	IFFUPJMP,		//	b		x				-				(x==nil)? PC-=b  
+	IFFUPJMPW,		//	w		x				-				(x==nil)? PC-=w  
 
-CLOSURE,/*	c	f v_c...v_1	closure(f, v_c...v_1) */
-CLOSURE0,/*	-	f		closure(f) */
-CLOSURE1,/*	-	f v		closure(f, v) */
+	CLOSURE,		//	c		f v_c...v_1		closure(f, v_c...v_1) 
+	CLOSURE0,		//	-		f				closure(f) 
+	CLOSURE1,		//	-		f v				closure(f, v) 
 
-CALLFUNC,/*	b c	v_c...v_1 f	r_b...r_1	f(v1,...,v_c)  */
-CALLFUNC0,/*	b	v_b...v_1 f	-		f(v1,...,v_b)  */
-CALLFUNC1,/*	b	v_b...v_1 f	r_1		f(v1,...,v_b)  */
+	CALLFUNC,		//	b c		v_c...v_1 f		r_b...r_1		f(v1,...,v_c)  
+	CALLFUNC0,		//	b		v_b...v_1 f		-				f(v1,...,v_b)  
+	CALLFUNC1,		//	b		v_b...v_1 f		r_1				f(v1,...,v_b)  
 
-RETCODE,/*	b	-		-  */
+	RETCODE,		//	b		-				-  
 
-SETLINE,/*	b	-		-		LINE=b  */
-SETLINEW,/*	w	-		-		LINE=w  */
+	SETLINE,		//	b		-				-				LINE=b  
+	SETLINEW,		//	w		-				-				LINE=w  
 
-POP,/*		b	-		-		TOP-=(b+1)  */
-POP0,/*		-	-		-		TOP-=1  */
-POP1/*		-	-		-		TOP-=2  */
-
+	POP,			//	b		-				-				TOP-=(b+1)
+	POP0,			//	-		-				-				TOP-=1
+	POP1			//	-		-				-				TOP-=2
 } OpCode;
 
-
-#define RFIELDS_PER_FLUSH 32	/* records (SETMAP) */
-#define LFIELDS_PER_FLUSH 64    /* lists (SETLIST) */
-
+#define RFIELDS_PER_FLUSH 32	// records (SETMAP)
+#define LFIELDS_PER_FLUSH 64    // lists (SETLIST)
 #define ZEROVARARG	64
 
 #endif

Modified: residual/trunk/engine/lua/lparser.cpp
===================================================================
--- residual/trunk/engine/lua/lparser.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lparser.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -5,37 +5,33 @@
 */
 
 
-#include "lauxlib.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "lua.h"
-#include "luadebug.h"
-#include "lzio.h"
+#include "engine/lua/lauxlib.h"
+#include "engine/lua/ldo.h"
+#include "engine/lua/lfunc.h"
+#include "engine/lua/llex.h"
+#include "engine/lua/lmem.h"
+#include "engine/lua/lopcodes.h"
+#include "engine/lua/lparser.h"
+#include "engine/lua/lstate.h"
+#include "engine/lua/lstring.h"
+#include "engine/lua/lua.h"
+#include "engine/lua/luadebug.h"
+#include "engine/lua/lzio.h"
 
-
-/* for limit numbers in error messages */
+// for limit numbers in error messages
 #define MES_LIM(x)      "(limit=" x ")"
 
-
-/* size of a "normal" jump instruction: OpCode + 1 byte */
+// size of a "normal" jump instruction: OpCode + 1 byte
 #define JMPSIZE	2
 
-/* maximum number of local variables */
+// maximum number of local variables
 #define MAXLOCALS 32
 #define SMAXLOCALS "32"
 
-
-/* maximum number of upvalues */
+// maximum number of upvalues
 #define MAXUPVALUES 16
 #define SMAXUPVALUES "16"
 
-
 /*
 ** Variable descriptor:
 ** must include a "exp" option because LL(1) cannot distinguish
@@ -45,14 +41,13 @@
 ** VDOT: info is constant index of index name
 ** VEXP: info is pc index of "nparam" of function call (or 0 if exp is closed)
 */
-typedef enum {VGLOBAL, VLOCAL, VDOT, VINDEXED, VEXP} varkind;
+typedef enum { VGLOBAL, VLOCAL, VDOT, VINDEXED, VEXP } varkind;
 
 typedef struct {
-  varkind k;
-  int32 info;
+	varkind k;
+	int32 info;
 } vardesc;
 
-
 /*
 ** Expression List descriptor:
 ** tells number of expressions in the list,
@@ -60,11 +55,10 @@
 ** where is its pc index of "nparam"
 */
 typedef struct {
-  int32 n;
-  int32 pc;  /* 0 if last expression is closed */
+	int32 n;
+	int32 pc;  // 0 if last expression is closed
 } listdesc;
 
-
 /*
 ** Constructors descriptor:
 ** "n" indicates number of elements, and "k" signals whether
@@ -72,789 +66,732 @@
 ** or empty (k = ';' or '}')
 */
 typedef struct {
-  int32 n;
-  int32 k;
+	int32 n;
+	int32 k;
 } constdesc;
 
-
-/* state needed to generate code for a given function */
+// state needed to generate code for a given function
 typedef struct FuncState {
-  TProtoFunc *f;  /* current function header */
-  struct FuncState *prev;  /* enclosuring function */
-  int32 pc;  /* next position to code */
-  int32 stacksize;  /* number of values on activation register */
-  int32 maxstacksize;  /* maximum number of values on activation register */
-  int32 nlocalvar;  /* number of active local variables */
-  int32 nupvalues;  /* number of upvalues */
-  int32 nvars;  /* number of entries in f->locvars */
-  int32 maxcode;  /* size of f->code */
-  int32 maxvars;  /* size of f->locvars (-1 if no debug information) */
-  int32 maxconsts;  /* size of f->consts */
-  int32 lastsetline;  /* line where last SETLINE was issued */
-  vardesc upvalues[MAXUPVALUES];  /* upvalues */
-  TaggedString *localvar[MAXLOCALS];  /* store local variable names */
+	TProtoFunc *f;  // current function header
+	struct FuncState *prev;  // enclosuring function
+	int32 pc;  // next position to code
+	int32 stacksize;  // number of values on activation register
+	int32 maxstacksize;  // maximum number of values on activation register
+	int32 nlocalvar;  // number of active local variables
+	int32 nupvalues;  // number of upvalues
+	int32 nvars;  // number of entries in f->locvars
+	int32 maxcode;  // size of f->code
+	int32 maxvars;  // size of f->locvars (-1 if no debug information)
+	int32 maxconsts;  // size of f->consts
+	int32 lastsetline;  // line where last SETLINE was issued
+	vardesc upvalues[MAXUPVALUES];  // upvalues
+	TaggedString *localvar[MAXLOCALS];  // store local variable names
 } FuncState;
 
+static int32 assignment(LexState *ls, vardesc *v, int32 nvars);
+static int32 cond(LexState *ls);
+static int32 funcname(LexState *ls, vardesc *v);
+static int32 funcparams(LexState *ls, int32 slf);
+static int32 listfields(LexState *ls);
+static int32 localnamelist(LexState *ls);
+static int32 optional(LexState *ls, int32 c);
+static int32 recfields(LexState *ls);
+static int32 stat(LexState *ls);
+static void block(LexState *ls);
+static void body(LexState *ls, int32 needself, int32 line);
+static void chunk(LexState *ls);
+static void constructor(LexState *ls);
+static void decinit(LexState *ls, listdesc *d);
+static void exp0(LexState *ls, vardesc *v);
+static void exp1(LexState *ls);
+static void exp2(LexState *ls, vardesc *v);
+static void explist(LexState *ls, listdesc *e);
+static void explist1(LexState *ls, listdesc *e);
+static void ifpart(LexState *ls);
+static void parlist(LexState *ls);
+static void part(LexState *ls, constdesc *cd);
+static void recfield(LexState *ls);
+static void ret(LexState *ls);
+static void simpleexp(LexState *ls, vardesc *v);
+static void statlist(LexState *ls);
+static void var_or_func(LexState *ls, vardesc *v);
+static void var_or_func_tail(LexState *ls, vardesc *v);
 
-static int32 assignment (LexState *ls, vardesc *v, int32 nvars);
-static int32 cond (LexState *ls);
-static int32 funcname (LexState *ls, vardesc *v);
-static int32 funcparams (LexState *ls, int32 slf);
-static int32 listfields (LexState *ls);
-static int32 localnamelist (LexState *ls);
-static int32 optional (LexState *ls, int32 c);
-static int32 recfields (LexState *ls);
-static int32 stat (LexState *ls);
-static void block (LexState *ls);
-static void body (LexState *ls, int32 needself, int32 line);
-static void chunk (LexState *ls);
-static void constructor (LexState *ls);
-static void decinit (LexState *ls, listdesc *d);
-static void exp0 (LexState *ls, vardesc *v);
-static void exp1 (LexState *ls);
-static void exp2 (LexState *ls, vardesc *v);
-static void explist (LexState *ls, listdesc *e);
-static void explist1 (LexState *ls, listdesc *e);
-static void ifpart (LexState *ls);
-static void parlist (LexState *ls);
-static void part (LexState *ls, constdesc *cd);
-static void recfield (LexState *ls);
-static void ret (LexState *ls);
-static void simpleexp (LexState *ls, vardesc *v);
-static void statlist (LexState *ls);
-static void var_or_func (LexState *ls, vardesc *v);
-static void var_or_func_tail (LexState *ls, vardesc *v);
-
-
-
-static void check_pc (FuncState *fs, int32 n) {
-  if (fs->pc+n > fs->maxcode)
-    fs->maxcode = luaM_growvector(&fs->f->code, fs->maxcode,
-                                  Byte, codeEM, MAX_INT);
+static void check_pc(FuncState *fs, int32 n) {
+	if (fs->pc + n > fs->maxcode)
+		fs->maxcode = luaM_growvector(&fs->f->code, fs->maxcode, byte, codeEM, MAX_INT);
 }
 
-
-static void code_byte (FuncState *fs, Byte c) {
-  check_pc(fs, 1);
-  fs->f->code[fs->pc++] = c;
+static void code_byte(FuncState *fs, byte c) {
+	check_pc(fs, 1);
+	fs->f->code[fs->pc++] = c;
 }
 
-
-static void deltastack (LexState *ls, int32 delta) {
-  FuncState *fs = ls->fs;
-  fs->stacksize += delta;
-  if (fs->stacksize > fs->maxstacksize) {
-    if (fs->stacksize > 255)
-      luaX_error(ls, "function/expression too complex");
-    fs->maxstacksize = fs->stacksize;
-  }
+static void deltastack(LexState *ls, int32 delta) {
+	FuncState *fs = ls->fs;
+	fs->stacksize += delta;
+	if (fs->stacksize > fs->maxstacksize) {
+		if (fs->stacksize > 255)
+			luaX_error(ls, "function/expression too complex");
+		fs->maxstacksize = fs->stacksize;
+	}
 }
 
-
-static int32 code_oparg_at (LexState *ls, int32 pc, OpCode op, int32 builtin,
-                          int32 arg, int32 delta) {
-  Byte *code = ls->fs->f->code;
-  deltastack(ls, delta);
-  if (arg < builtin) {
-    code[pc] = op+1+arg;
-    return 1;
-  }
-  else if (arg <= 255) {
-    code[pc] = op;
-    code[pc+1] = arg;
-    return 2;
-  }
-  else if (arg <= MAX_WORD) {
-    code[pc] = op+1+builtin;
-    code[pc+2] = arg>>8;
-    code[pc+1] = arg&0xFF;
-    return 3;
-  }
-  else luaX_error(ls, "code too long " MES_LIM("64K"));
-  return 0;   /* to avoid warnings */
+static int32 code_oparg_at(LexState *ls, int32 pc, OpCode op, int32 builtin, int32 arg, int32 delta) {
+	byte *code = ls->fs->f->code;
+	deltastack(ls, delta);
+	if (arg < builtin) {
+		code[pc] = op + 1 + arg;
+		return 1;
+	} else if (arg <= 255) {
+		code[pc] = op;
+		code[pc + 1] = arg;
+		return 2;
+	} else if (arg <= MAX_WORD) {
+		code[pc] = op + 1 + builtin;
+		code[pc + 2] = arg >> 8;
+		code[pc + 1] = arg & 0xFF;
+		return 3;
+	} else
+		luaX_error(ls, "code too long " MES_LIM("64K"));
+	return 0;   // to avoid warnings
 }
 
-
-static int32 fix_opcode (LexState *ls, int32 pc, OpCode op, int32 builtin, int32 arg) {
-  FuncState *fs = ls->fs;
-  TProtoFunc *f = fs->f;
-  if (arg < builtin) {  /* close space */
-    luaO_memdown(f->code+pc+1, f->code+pc+2, fs->pc-(pc+2));
-    fs->pc--;
-  }
-  else if (arg > 255) {  /* open space */
-    check_pc(fs, 1);
-    luaO_memup(f->code+pc+1, f->code+pc, fs->pc-pc);
-    fs->pc++;
-  }
-  return code_oparg_at(ls, pc, op, builtin, arg, 0) - 2;
+static int32 fix_opcode(LexState *ls, int32 pc, OpCode op, int32 builtin, int32 arg) {
+	FuncState *fs = ls->fs;
+	TProtoFunc *f = fs->f;
+	if (arg < builtin) {  // close space
+		luaO_memdown(f->code + pc + 1, f->code + pc + 2, fs->pc - (pc + 2));
+		fs->pc--;
+	} else if (arg > 255) {  // open space
+		check_pc(fs, 1);
+		luaO_memup(f->code + pc + 1, f->code + pc, fs->pc - pc);
+		fs->pc++;
+	}
+	return code_oparg_at(ls, pc, op, builtin, arg, 0) - 2;
 }
 
-static void code_oparg (LexState *ls, OpCode op, int32 builtin, int32 arg,
-                        int32 delta) {
-  check_pc(ls->fs, 3);  /* maximum code size */
-  ls->fs->pc += code_oparg_at(ls, ls->fs->pc, op, builtin, arg, delta);
+static void code_oparg(LexState *ls, OpCode op, int32 builtin, int32 arg, int32 delta) {
+	check_pc(ls->fs, 3);  // maximum code size
+	ls->fs->pc += code_oparg_at(ls, ls->fs->pc, op, builtin, arg, delta);
 }
 
-
-static void code_opcode (LexState *ls, OpCode op, int32 delta) {
-  deltastack(ls, delta);
-  code_byte(ls->fs, op);
+static void code_opcode(LexState *ls, OpCode op, int32 delta) {
+	deltastack(ls, delta);
+	code_byte(ls->fs, op);
 }
 
-
-static void code_constant (LexState *ls, int32 c) {
-  code_oparg(ls, PUSHCONSTANT, 8, c, 1);
+static void code_constant(LexState *ls, int32 c) {
+	code_oparg(ls, PUSHCONSTANT, 8, c, 1);
 }
 
-
-static int32 next_constant (FuncState *fs) {
-  TProtoFunc *f = fs->f;
-  if (f->nconsts >= fs->maxconsts) {
-    fs->maxconsts = luaM_growvector(&f->consts, fs->maxconsts, TObject,
-                                    constantEM, MAX_WORD);
-  }
-  return f->nconsts++;
+static int32 next_constant(FuncState *fs) {
+	TProtoFunc *f = fs->f;
+	if (f->nconsts >= fs->maxconsts) {
+		fs->maxconsts = luaM_growvector(&f->consts, fs->maxconsts, TObject, constantEM, MAX_WORD);
+	}
+	return f->nconsts++;
 }
 
-
-static int32 string_constant (FuncState *fs, TaggedString *s) {
-  TProtoFunc *f = fs->f;
-  int32 c = s->constindex;
-  if (!(c < f->nconsts &&
-      ttype(&f->consts[c]) == LUA_T_STRING && tsvalue(&f->consts[c]) == s)) {
-    c = next_constant(fs);
-    ttype(&f->consts[c]) = LUA_T_STRING;
-    tsvalue(&f->consts[c]) = s;
-    s->constindex = c;  /* hint for next time */
-  }
-  return c;
+static int32 string_constant(FuncState *fs, TaggedString *s) {
+	TProtoFunc *f = fs->f;
+	int32 c = s->constindex;
+	if (!(c < f->nconsts && ttype(&f->consts[c]) == LUA_T_STRING && tsvalue(&f->consts[c]) == s)) {
+		c = next_constant(fs);
+		ttype(&f->consts[c]) = LUA_T_STRING;
+		tsvalue(&f->consts[c]) = s;
+		s->constindex = c;  // hint for next time
+	}
+	return c;
 }
 
-
-static void code_string (LexState *ls, TaggedString *s) {
-  code_constant(ls, string_constant(ls->fs, s));
+static void code_string(LexState *ls, TaggedString *s) {
+	code_constant(ls, string_constant(ls->fs, s));
 }
 
-
 #define LIM 20
-static int32 real_constant (FuncState *fs, real r) {
-  /* check whether 'r' has appeared within the last LIM entries */
-  TObject *cnt = fs->f->consts;
-  int32 c = fs->f->nconsts;
-  int32 lim = c < LIM ? 0 : c-LIM;
-  while (--c >= lim) {
-    if (ttype(&cnt[c]) == LUA_T_NUMBER && nvalue(&cnt[c]) == r)
-      return c;
-  }
-  /* not found; create a luaM_new entry */
-  c = next_constant(fs);
-  cnt = fs->f->consts;  /* 'next_constant' may reallocate this vector */
-  ttype(&cnt[c]) = LUA_T_NUMBER;
-  nvalue(&cnt[c]) = r;
-  return c;
+static int32 real_constant(FuncState *fs, real r) {
+	// check whether 'r' has appeared within the last LIM entries
+	TObject *cnt = fs->f->consts;
+	int32 c = fs->f->nconsts;
+	int32 lim = c < LIM ? 0 : c-LIM;
+	while (--c >= lim) {
+		if (ttype(&cnt[c]) == LUA_T_NUMBER && nvalue(&cnt[c]) == r)
+			return c;
+	}
+	// not found; create a luaM_new entry
+	c = next_constant(fs);
+	cnt = fs->f->consts;  // 'next_constant' may reallocate this vector
+	ttype(&cnt[c]) = LUA_T_NUMBER;
+	nvalue(&cnt[c]) = r;
+	return c;
 }
 
-
-static void code_number (LexState *ls, real f) {
-  int32 i;
-  if (f >= 0 && f <= (real)MAX_WORD && (real)(i=(int32)f) == f)
-    code_oparg(ls, PUSHNUMBER, 3, i, 1);  /* f has a short integer value */
-  else
-    code_constant(ls, real_constant(ls->fs, f));
+static void code_number(LexState *ls, real f) {
+	int32 i;
+	if (f >= 0 && f <= (real)MAX_WORD && (real)(i = (int32)f) == f)
+		code_oparg(ls, PUSHNUMBER, 3, i, 1);  // f has a short integer value
+	else
+		code_constant(ls, real_constant(ls->fs, f));
 }
 
-
-static void flush_record (LexState *ls, int32 n) {
-  if (n > 0)
-    code_oparg(ls, SETMAP, 1, n-1, -2*n);
+static void flush_record(LexState *ls, int32 n) {
+	if (n > 0)
+		code_oparg(ls, SETMAP, 1, n - 1, -2 * n);
 }
 
-
-static void flush_list (LexState *ls, int32 m, int32 n) {
-  if (n == 0) return;
-  code_oparg(ls, SETLIST, 1, m, -n);
-  code_byte(ls->fs, n);
+static void flush_list(LexState *ls, int32 m, int32 n) {
+	if (n == 0)
+		return;
+	code_oparg(ls, SETLIST, 1, m, -n);
+	code_byte(ls->fs, n);
 }
 
-
-static void luaI_registerlocalvar (FuncState *fs, TaggedString *varname,
-                                   int32 line) {
-  if (fs->maxvars != -1) {  /* debug information? */
-    TProtoFunc *f = fs->f;
-    if (fs->nvars >= fs->maxvars)
-      fs->maxvars = luaM_growvector(&f->locvars, fs->maxvars,
-                                    LocVar, "", MAX_WORD);
-    f->locvars[fs->nvars].varname = varname;
-    f->locvars[fs->nvars].line = line;
-    fs->nvars++;
-  }
+static void luaI_registerlocalvar(FuncState *fs, TaggedString *varname, int32 line) {
+	if (fs->maxvars != -1) {  // debug information?
+		TProtoFunc *f = fs->f;
+		if (fs->nvars >= fs->maxvars)
+			fs->maxvars = luaM_growvector(&f->locvars, fs->maxvars, LocVar, "", MAX_WORD);
+		f->locvars[fs->nvars].varname = varname;
+		f->locvars[fs->nvars].line = line;
+		fs->nvars++;
+	}
 }
 
-
-static void luaI_unregisterlocalvar (FuncState *fs, int32 line) {
-  luaI_registerlocalvar(fs, NULL, line);
+static void luaI_unregisterlocalvar(FuncState *fs, int32 line) {
+	luaI_registerlocalvar(fs, NULL, line);
 }
 
-
-static void store_localvar (LexState *ls, TaggedString *name, int32 n) {
-  FuncState *fs = ls->fs;
-  if (fs->nlocalvar+n < MAXLOCALS)
-    fs->localvar[fs->nlocalvar+n] = name;
-  else
-    luaX_error(ls, "too many local variables " MES_LIM(SMAXLOCALS));
-  luaI_registerlocalvar(fs, name, ls->linenumber);
+static void store_localvar(LexState *ls, TaggedString *name, int32 n) {
+	FuncState *fs = ls->fs;
+	if (fs->nlocalvar + n < MAXLOCALS)
+		fs->localvar[fs->nlocalvar + n] = name;
+	else
+		luaX_error(ls, "too many local variables " MES_LIM(SMAXLOCALS));
+	luaI_registerlocalvar(fs, name, ls->linenumber);
 }
 
-
-static void add_localvar (LexState *ls, TaggedString *name) {
-  store_localvar(ls, name, 0);
-  ls->fs->nlocalvar++;
+static void add_localvar(LexState *ls, TaggedString *name) {
+	store_localvar(ls, name, 0);
+	ls->fs->nlocalvar++;
 }
 
-
-static int32 aux_localname (FuncState *fs, TaggedString *n) {
-  int32 i;
-  for (i=fs->nlocalvar-1; i >= 0; i--)
-    if (n == fs->localvar[i]) return i;  /* local var index */
-  return -1;  /* not found */
+static int32 aux_localname(FuncState *fs, TaggedString *n) {
+	int32 i;
+	for (i = fs->nlocalvar - 1; i >= 0; i--)
+		if (n == fs->localvar[i])
+			return i;  // local var index
+	return -1;  // not found
 }
 
-
-static void singlevar (LexState *ls, TaggedString *n, vardesc *var, int32 prev) {
-  FuncState *fs = prev ? ls->fs->prev : ls->fs;
-  int32 i = aux_localname(fs, n);
-  if (i >= 0) {  /* local value */
-    var->k = VLOCAL;
-    var->info = i;
-  }
-  else {  /* check shadowing */
-    FuncState *level = fs;
-    while ((level = level->prev) != NULL)
-      if (aux_localname(level, n) >= 0)
-        luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str);
-    var->k = VGLOBAL;
-    var->info = string_constant(fs, n);
-  }
+static void singlevar(LexState *ls, TaggedString *n, vardesc *var, int32 prev) {
+	FuncState *fs = prev ? ls->fs->prev : ls->fs;
+	int32 i = aux_localname(fs, n);
+	if (i >= 0) {  // local value
+		var->k = VLOCAL;
+		var->info = i;
+	} else {  // check shadowing
+		FuncState *level = fs;
+		while (level = level->prev)
+			if (aux_localname(level, n) >= 0)
+				luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str);
+		var->k = VGLOBAL;
+		var->info = string_constant(fs, n);
+	}
 }
 
-
-static int32 indexupvalue (LexState *ls, TaggedString *n) {
-  FuncState *fs = ls->fs;
-  vardesc v;
-  int32 i;
-  singlevar(ls, n, &v, 1);
-  for (i=0; i<fs->nupvalues; i++) {
-    if (fs->upvalues[i].k == v.k && fs->upvalues[i].info == v.info)
-      return i;
-  }
-  /* new one */
-  if (++(fs->nupvalues) > MAXUPVALUES)
-    luaX_error(ls, "too many upvalues in a single function "
-                   MES_LIM(SMAXUPVALUES));
-  fs->upvalues[i] = v;  /* i = fs->nupvalues - 1 */
-  return i;
+static int32 indexupvalue(LexState *ls, TaggedString *n) {
+	FuncState *fs = ls->fs;
+	vardesc v;
+	int32 i;
+	singlevar(ls, n, &v, 1);
+	for (i = 0; i < fs->nupvalues; i++) {
+		if (fs->upvalues[i].k == v.k && fs->upvalues[i].info == v.info)
+			return i;
+	}
+	// new one
+	if (++(fs->nupvalues) > MAXUPVALUES)
+		luaX_error(ls, "too many upvalues in a single function " MES_LIM(SMAXUPVALUES));
+	fs->upvalues[i] = v;  // i = fs->nupvalues - 1
+	return i;
 }
 
-
-static void pushupvalue (LexState *ls, TaggedString *n) {
-  int32 i;
-  if (ls->fs->prev == NULL)
-    luaX_syntaxerror(ls, "cannot access upvalue in main", n->str);
-  if (aux_localname(ls->fs, n) >= 0)
-    luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str);
-  i = indexupvalue(ls, n);
-  code_oparg(ls, PUSHUPVALUE, 2, i, 1);
+static void pushupvalue(LexState *ls, TaggedString *n) {
+	int32 i;
+	if (!ls->fs->prev)
+		luaX_syntaxerror(ls, "cannot access upvalue in main", n->str);
+	if (aux_localname(ls->fs, n) >= 0)
+		luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str);
+	i = indexupvalue(ls, n);
+	code_oparg(ls, PUSHUPVALUE, 2, i, 1);
 }
 
-
-
-static void check_debugline (LexState *ls) {
-  if (lua_debug && ls->linenumber != ls->fs->lastsetline) {
-    code_oparg(ls, SETLINE, 0, ls->linenumber, 0);
-    ls->fs->lastsetline = ls->linenumber;
-  }
+static void check_debugline(LexState *ls) {
+	if (lua_debug && ls->linenumber != ls->fs->lastsetline) {
+		code_oparg(ls, SETLINE, 0, ls->linenumber, 0);
+		ls->fs->lastsetline = ls->linenumber;
+	}
 }
 
-
-static void adjuststack (LexState *ls, int32 n) {
-  if (n > 0)
-    code_oparg(ls, POP, 2, n-1, -n);
-  else if (n < 0)
-    code_oparg(ls, PUSHNIL, 1, (-n)-1, -n);
+static void adjuststack(LexState *ls, int32 n) {
+	if (n > 0)
+		code_oparg(ls, POP, 2, n - 1, -n);
+	else if (n < 0)
+		code_oparg(ls, PUSHNIL, 1, (-n) - 1, -n);
 }
 
-
-static void close_exp (LexState *ls, int32 pc, int32 nresults) {
-  if (pc > 0) {  /* expression is an open function call */
-    Byte *code = ls->fs->f->code;
-    int32 nparams = code[pc];  /* save nparams */
-    pc += fix_opcode(ls, pc-2, CALLFUNC, 2, nresults);
-    code[pc] = nparams;  /* restore nparams */
-    if (nresults != MULT_RET)
-      deltastack(ls, nresults);  /* "push" results */
-    deltastack(ls, -(nparams+1));  /* "pop" params and function */
-  }
+static void close_exp(LexState *ls, int32 pc, int32 nresults) {
+	if (pc > 0) {  // expression is an open function call
+		byte *code = ls->fs->f->code;
+		int32 nparams = code[pc];  // save nparams
+		pc += fix_opcode(ls, pc - 2, CALLFUNC, 2, nresults);
+		code[pc] = nparams;  // restore nparams
+		if (nresults != MULT_RET)
+			deltastack(ls, nresults);  // "push" results
+		deltastack(ls, -(nparams + 1));  // "pop" params and function
+	}
 }
 
-
-static void adjust_mult_assign (LexState *ls, int32 nvars, listdesc *d) {
-  int32 diff = d->n - nvars;
-  if (d->pc == 0) {  /* list is closed */
-    /* push or pop eventual difference between list lengths */
-    adjuststack(ls, diff);
-  }
-  else {  /* must correct function call */
-    diff--;  /* do not count function call itself */
-    if (diff < 0) {  /* more variables than values */
-      /* function call must provide extra values */
-      close_exp(ls, d->pc, -diff);
-    }
-    else {  /* more values than variables */
-      close_exp(ls, d->pc, 0);  /* call should provide no value */
-      adjuststack(ls, diff);  /* pop eventual extra values */
-    }
-  }
+static void adjust_mult_assign(LexState *ls, int32 nvars, listdesc *d) {
+	int32 diff = d->n - nvars;
+	if (d->pc == 0) {  // list is closed
+		// push or pop eventual difference between list lengths
+		adjuststack(ls, diff);
+	} else {  // must correct function call
+		diff--;  // do not count function call itself
+		if (diff < 0) {  // more variables than values
+			// function call must provide extra values
+			close_exp(ls, d->pc, -diff);
+		} else {  // more values than variables
+			close_exp(ls, d->pc, 0);  // call should provide no value
+			adjuststack(ls, diff);  // pop eventual extra values
+		}
+	}
 }
 
-
-static void code_args (LexState *ls, int32 nparams, int32 dots) {
-  FuncState *fs = ls->fs;
-  fs->nlocalvar += nparams;  /* "self" may already be there */
-  nparams = fs->nlocalvar;
-  if (!dots) {
-    fs->f->code[1] = nparams;  /* fill-in arg information */
-    deltastack(ls, nparams);
-  }
-  else {
-    fs->f->code[1] = nparams+ZEROVARARG;
-    deltastack(ls, nparams+1);
-    add_localvar(ls, luaS_new("arg"));
-  }
+static void code_args(LexState *ls, int32 nparams, int32 dots) {
+	FuncState *fs = ls->fs;
+	fs->nlocalvar += nparams;  // "self" may already be there
+	nparams = fs->nlocalvar;
+	if (!dots) {
+		fs->f->code[1] = nparams;  // fill-in arg information
+		deltastack(ls, nparams);
+	} else {
+		fs->f->code[1] = nparams + ZEROVARARG;
+		deltastack(ls, nparams + 1);
+		add_localvar(ls, luaS_new("arg"));
+	}
 }
 
-
-static void lua_pushvar (LexState *ls, vardesc *var) {
-  switch (var->k) {
-    case VLOCAL:
-      code_oparg(ls, PUSHLOCAL, 8, var->info, 1);
-      break;
-    case VGLOBAL:
-      code_oparg(ls, GETGLOBAL, 8, var->info, 1);
-      break;
-    case VDOT:
-      code_oparg(ls, GETDOTTED, 8, var->info, 0);
-      break;
-    case VINDEXED:
-      code_opcode(ls, GETTABLE, -1);
-      break;
-    case VEXP:
-      close_exp(ls, var->info, 1);  /* function must return 1 value */
-      break;
-  }
-  var->k = VEXP;
-  var->info = 0;  /* now this is a closed expression */
+static void lua_pushvar(LexState *ls, vardesc *var) {
+	switch (var->k) {
+	case VLOCAL:
+		code_oparg(ls, PUSHLOCAL, 8, var->info, 1);
+		break;
+	case VGLOBAL:
+		code_oparg(ls, GETGLOBAL, 8, var->info, 1);
+		break;
+	case VDOT:
+		code_oparg(ls, GETDOTTED, 8, var->info, 0);
+		break;
+	case VINDEXED:
+		code_opcode(ls, GETTABLE, -1);
+		break;
+	case VEXP:
+		close_exp(ls, var->info, 1);  // function must return 1 value
+		break;
+	}
+	var->k = VEXP;
+	var->info = 0;  // now this is a closed expression
 }
 
-
 static void storevar (LexState *ls, vardesc *var) {
-  switch (var->k) {
-    case VLOCAL:
-      code_oparg(ls, SETLOCAL, 8, var->info, -1);
-      break;
-    case VGLOBAL:
-      code_oparg(ls, SETGLOBAL, 8, var->info, -1);
-      break;
-    case VINDEXED:
-      code_opcode(ls, SETTABLE0, -3);
-      break;
-    default:
-      LUA_INTERNALERROR("invalid var kind to store");
-  }
+	switch (var->k) {
+	case VLOCAL:
+		code_oparg(ls, SETLOCAL, 8, var->info, -1);
+		break;
+	case VGLOBAL:
+		code_oparg(ls, SETGLOBAL, 8, var->info, -1);
+		break;
+	case VINDEXED:
+		code_opcode(ls, SETTABLE0, -3);
+		break;
+	default:
+		LUA_INTERNALERROR("invalid var kind to store");
+	}
 }
 
-
-static int32 fixJump (LexState *ls, int32 pc, OpCode op, int32 n) {
-  /* jump is relative to position following jump instruction */
-  return fix_opcode(ls, pc, op, 0, n-(pc+JMPSIZE));
+static int32 fixJump(LexState *ls, int32 pc, OpCode op, int32 n) {
+	// jump is relative to position following jump instruction
+	return fix_opcode(ls, pc, op, 0, n - (pc + JMPSIZE));
 }
 
-
-static void fix_upjmp (LexState *ls, OpCode op, int32 pos) {
-  int32 delta = ls->fs->pc+JMPSIZE - pos;  /* jump is relative */
-  if (delta > 255) delta++;
-  code_oparg(ls, op, 0, delta, 0);
+static void fix_upjmp(LexState *ls, OpCode op, int32 pos) {
+	int32 delta = ls->fs->pc + JMPSIZE - pos;  // jump is relative
+	if (delta > 255)
+		delta++;
+	code_oparg(ls, op, 0, delta, 0);
 }
 
-
-static void codeIf (LexState *ls, int32 thenAdd, int32 elseAdd) {
-  FuncState *fs = ls->fs;
-  int32 elseinit = elseAdd+JMPSIZE;
-  if (fs->pc == elseinit) {  /* no else part */
-    fs->pc -= JMPSIZE;
-    elseinit = fs->pc;
-  }
-  else
-    elseinit += fixJump(ls, elseAdd, JMP, fs->pc);
-  fixJump(ls, thenAdd, IFFJMP, elseinit);
+static void codeIf(LexState *ls, int32 thenAdd, int32 elseAdd) {
+	FuncState *fs = ls->fs;
+	int32 elseinit = elseAdd + JMPSIZE;
+	if (fs->pc == elseinit) {  // no else part
+		fs->pc -= JMPSIZE;
+		elseinit = fs->pc;
+	} else
+		elseinit += fixJump(ls, elseAdd, JMP, fs->pc);
+	fixJump(ls, thenAdd, IFFJMP, elseinit);
 }
 
-
-static void func_onstack (LexState *ls, FuncState *func) {
-  FuncState *fs = ls->fs;
-  int32 i;
-  int32 c = next_constant(fs);
-  ttype(&fs->f->consts[c]) = LUA_T_PROTO;
-  fs->f->consts[c].value.tf = func->f;
-  if (func->nupvalues == 0)
-    code_constant(ls, c);
-  else {
-    for (i=0; i<func->nupvalues; i++)
-      lua_pushvar(ls, &func->upvalues[i]);
-    code_oparg(ls, CLOSURE, 0, c, -func->nupvalues+1);
-    code_byte(fs, func->nupvalues);
-  }
+static void func_onstack(LexState *ls, FuncState *func) {
+	FuncState *fs = ls->fs;
+	int32 i;
+	int32 c = next_constant(fs);
+	ttype(&fs->f->consts[c]) = LUA_T_PROTO;
+	fs->f->consts[c].value.tf = func->f;
+	if (func->nupvalues == 0)
+		code_constant(ls, c);
+	else {
+		for (i = 0; i < func->nupvalues; i++)
+			lua_pushvar(ls, &func->upvalues[i]);
+		code_oparg(ls, CLOSURE, 0, c, -func->nupvalues + 1);
+		code_byte(fs, func->nupvalues);
+	}
 }
 
-
-static void init_state (LexState *ls, FuncState *fs, TaggedString *filename) {
-  TProtoFunc *f = luaF_newproto();
-  fs->prev = ls->fs;  /* linked list of funcstates */
-  ls->fs = fs;
-  fs->stacksize = 0;
-  fs->maxstacksize = 0;
-  fs->nlocalvar = 0;
-  fs->nupvalues = 0;
-  fs->lastsetline = 0;
-  fs->f = f;
-  f->fileName = filename;
-  fs->pc = 0;
-  fs->maxcode = 0;
-  f->code = NULL;
-  fs->maxconsts = 0;
-  if (lua_debug)
-    fs->nvars = fs->maxvars = 0;
-  else
-    fs->maxvars = -1;  /* flag no debug information */
-  code_byte(fs, 0);  /* to be filled with stacksize */
-  code_byte(fs, 0);  /* to be filled with arg information */
+static void init_state(LexState *ls, FuncState *fs, TaggedString *filename) {
+	TProtoFunc *f = luaF_newproto();
+	fs->prev = ls->fs;  // linked list of funcstates
+	ls->fs = fs;
+	fs->stacksize = 0;
+	fs->maxstacksize = 0;
+	fs->nlocalvar = 0;
+	fs->nupvalues = 0;
+	fs->lastsetline = 0;
+	fs->f = f;
+	f->fileName = filename;
+	fs->pc = 0;
+	fs->maxcode = 0;
+	f->code = NULL;
+	fs->maxconsts = 0;
+	if (lua_debug)
+		fs->nvars = fs->maxvars = 0;
+	else
+		fs->maxvars = -1;  // flag no debug information
+	code_byte(fs, 0);  // to be filled with stacksize
+	code_byte(fs, 0);  // to be filled with arg information
 }
 
-
-static void close_func (LexState *ls) {
-  FuncState *fs = ls->fs;
-  TProtoFunc *f = fs->f;
-  code_opcode(ls, ENDCODE, 0);
-  f->code[0] = fs->maxstacksize;
-  f->code = luaM_reallocvector(f->code, fs->pc, Byte);
-  f->consts = luaM_reallocvector(f->consts, f->nconsts, TObject);
-  if (fs->maxvars != -1) {  /* debug information? */
-    luaI_registerlocalvar(fs, NULL, -1);  /* flag end of vector */
-    f->locvars = luaM_reallocvector(f->locvars, fs->nvars, LocVar);
-  }
-  ls->fs = fs->prev;
+static void close_func(LexState *ls) {
+	FuncState *fs = ls->fs;
+	TProtoFunc *f = fs->f;
+	code_opcode(ls, ENDCODE, 0);
+	f->code[0] = fs->maxstacksize;
+	f->code = luaM_reallocvector(f->code, fs->pc, byte);
+	f->consts = luaM_reallocvector(f->consts, f->nconsts, TObject);
+	if (fs->maxvars != -1) {  // debug information?
+		luaI_registerlocalvar(fs, NULL, -1);  // flag end of vector
+		f->locvars = luaM_reallocvector(f->locvars, fs->nvars, LocVar);
+	}
+	ls->fs = fs->prev;
 }
 
+static int32 expfollow [] = { ELSE, ELSEIF, THEN, IF, WHILE, REPEAT, DO, NAME,
+	LOCAL, FUNCTION, END, UNTIL, RETURN, ')', ']', '}', ';', EOS, ',',  0
+};
 
-
-static int32 expfollow [] = {ELSE, ELSEIF, THEN, IF, WHILE, REPEAT, DO, NAME,
-   LOCAL, FUNCTION, END, UNTIL, RETURN, ')', ']', '}', ';', EOS, ',',  0};
-
 static int32 is_in (int32 tok, int32 *toks) {
-  int32 *t = toks;
-  while (*t) {
-    if (*t == tok)
-      return t-toks;
-    t++;
-  }
-  return -1;
+	int32 *t = toks;
+	while (*t) {
+		if (*t == tok)
+			return
+		t-toks;
+		t++;
+	}
+	return -1;
 }
 
-
-static void next (LexState *ls) {
-  ls->token = luaX_lex(ls);
+static void next(LexState *ls) {
+	ls->token = luaX_lex(ls);
 }
 
+static void error_expected(LexState *ls, int32 token) {
+	char buff[100], t[TOKEN_LEN];
 
-static void error_expected (LexState *ls, int32 token) {
-  char buff[100], t[TOKEN_LEN];
-  luaX_token2str(ls, token, t);
-  sprintf(buff, "`%s' expected", t);
-  luaX_error(ls, buff);
+	luaX_token2str(ls, token, t);
+	sprintf(buff, "`%s' expected", t);
+	luaX_error(ls, buff);
 }
 
-static void error_unmatched (LexState *ls, int32 what, int32 who, int32 where) {
-  if (where == ls->linenumber)
-    error_expected(ls, what);
-  else {
-    char buff[100];
-    char t_what[TOKEN_LEN], t_who[TOKEN_LEN];
-    luaX_token2str(ls, what, t_what);
-    luaX_token2str(ls, who, t_who);
-    sprintf(buff, "`%s' expected (to close `%s' at line %d)",
-            t_what, t_who, (int)where);
-    luaX_error(ls, buff);
-  }
+static void error_unmatched(LexState *ls, int32 what, int32 who, int32 where) {
+	if (where == ls->linenumber)
+		error_expected(ls, what);
+	else {
+		char buff[100];
+		char t_what[TOKEN_LEN], t_who[TOKEN_LEN];
+		luaX_token2str(ls, what, t_what);
+		luaX_token2str(ls, who, t_who);
+		sprintf(buff, "`%s' expected (to close `%s' at line %d)", t_what, t_who, (int)where);
+		luaX_error(ls, buff);
+	}
 }
 
-static void check (LexState *ls, int32 c) {
-  if (ls->token != c)
-    error_expected(ls, c);
-  next(ls);
+static void check(LexState *ls, int32 c) {
+	if (ls->token != c)
+		error_expected(ls, c);
+	next(ls);
 }
 
-static void check_match (LexState *ls, int32 what, int32 who, int32 where) {
-  if (ls->token != what)
-    error_unmatched(ls, what, who, where);
-  check_debugline(ls);  /* to 'mark' the 'what' */
-  next(ls);
+static void check_match(LexState *ls, int32 what, int32 who, int32 where) {
+	if (ls->token != what)
+		error_unmatched(ls, what, who, where);
+	check_debugline(ls);  // to 'mark' the 'what'
+	next(ls);
 }
 
-static TaggedString *checkname (LexState *ls) {
-  TaggedString *ts;
-  if (ls->token != NAME)
-    luaX_error(ls, "`NAME' expected");
-  ts = ls->seminfo.ts;
-  next(ls);
-  return ts;
+static TaggedString *checkname(LexState *ls) {
+	TaggedString *ts;
+	if (ls->token != NAME)
+		luaX_error(ls, "`NAME' expected");
+	ts = ls->seminfo.ts;
+	next(ls);
+	return ts;
 }
 
-
-static int32 optional (LexState *ls, int32 c) {
-  if (ls->token == c) {
-    next(ls);
-    return 1;
-  }
-  else return 0;
+static int32 optional(LexState *ls, int32 c) {
+	if (ls->token == c) {
+		next(ls);
+		return 1;
+	} else
+		return 0;
 }
 
-
 TProtoFunc *luaY_parser (ZIO *z) {
-  struct LexState lexstate;
-  struct FuncState funcstate;
-  luaX_setinput(&lexstate, z);
-  init_state(&lexstate, &funcstate, luaS_new(zname(z)));
-  next(&lexstate);  /* read first token */
-  chunk(&lexstate);
-  if (lexstate.token != EOS)
-    luaX_error(&lexstate, "<eof> expected");
-  close_func(&lexstate);
-  return funcstate.f;
+	LexState lexstate;
+	FuncState funcstate;
+	luaX_setinput(&lexstate, z);
+	init_state(&lexstate, &funcstate, luaS_new(zname(z)));
+	next(&lexstate);  // read first token
+	chunk(&lexstate);
+	if (lexstate.token != EOS)
+		luaX_error(&lexstate, "<eof> expected");
+	close_func(&lexstate);
+	return funcstate.f;
 }
 
-
-
 /*============================================================*/
 /* GRAMAR RULES */
 /*============================================================*/
 
-static void chunk (LexState *ls) {
-  /* chunk -> statlist ret */
-  statlist(ls);
-  ret(ls);
+static void chunk(LexState *ls) {
+	// chunk -> statlist ret
+	statlist(ls);
+	ret(ls);
 }
 
-static void statlist (LexState *ls) {
-  /* statlist -> { stat [;] } */
-  while (stat(ls)) {
-    LUA_ASSERT(ls->fs->stacksize == ls->fs->nlocalvar,
-               "stack size != # local vars");
-    optional(ls, ';');
-  }
+static void statlist(LexState *ls) {
+	// statlist -> { stat [;] }
+	while (stat(ls)) {
+		LUA_ASSERT(ls->fs->stacksize == ls->fs->nlocalvar, "stack size != # local vars");
+		optional(ls, ';');
+	}
 }
 
-static int32 stat (LexState *ls) {
-  int32 line = ls->linenumber;  /* may be needed for error messages */
-  FuncState *fs = ls->fs;
-  switch (ls->token) {
-    case IF: {  /* stat -> IF ifpart END */
-      next(ls);
-      ifpart(ls);
-      check_match(ls, END, IF, line);
-      return 1;
-    }
-
-    case WHILE: {  /* stat -> WHILE cond DO block END */
-      TProtoFunc *f = fs->f;
-      int32 while_init = fs->pc;
-      int32 cond_end, cond_size;
-      next(ls);
-      cond_end = cond(ls);
-      check(ls, DO);
-      block(ls);
-      check_match(ls, END, WHILE, line);
-      cond_size = cond_end-while_init;
-      check_pc(fs, cond_size);
-      memcpy(f->code+fs->pc, f->code+while_init, cond_size);
-      luaO_memdown(f->code+while_init, f->code+cond_end, fs->pc-while_init);
-      while_init += JMPSIZE + fixJump(ls, while_init, JMP, fs->pc-cond_size);
-      fix_upjmp(ls, IFTUPJMP, while_init);
-      return 1;
-    }
-
-    case DO: {  /* stat -> DO block END */
-      next(ls);
-      block(ls);
-      check_match(ls, END, DO, line);
-      return 1;
-    }
-
-    case REPEAT: {  /* stat -> REPEAT block UNTIL exp1 */
-      int32 repeat_init = fs->pc;
-      next(ls);
-      block(ls);
-      check_match(ls, UNTIL, REPEAT, line);
-      exp1(ls);
-      fix_upjmp(ls, IFFUPJMP, repeat_init);
-      deltastack(ls, -1);  /* pops condition */
-      return 1;
-    }
-
-    case FUNCTION: {  /* stat -> FUNCTION funcname body */
-      int32 needself;
-      vardesc v;
-      if (ls->fs->prev)  /* inside other function? */
-        return 0;
-      check_debugline(ls);
-      next(ls);
-      needself = funcname(ls, &v);
-      body(ls, needself, line);
-      storevar(ls, &v);
-      return 1;
-    }
-
-    case LOCAL: {  /* stat -> LOCAL localnamelist decinit */
-      listdesc d;
-      int32 nvars;
-      check_debugline(ls);
-      next(ls);
-      nvars = localnamelist(ls);
-      decinit(ls, &d);
-      ls->fs->nlocalvar += nvars;
-      adjust_mult_assign(ls, nvars, &d);
-      return 1;
-    }
-
-    case NAME: case '%': {  /* stat -> func | ['%'] NAME assignment */
-      vardesc v;
-      check_debugline(ls);
-      var_or_func(ls, &v);
-      if (v.k == VEXP) {  /* stat -> func */
-        if (v.info == 0)  /* is just an upper value? */
-          luaX_error(ls, "syntax error");
-        close_exp(ls, v.info, 0);
-      }
-      else {
-        int32 left = assignment(ls, &v, 1);  /* stat -> ['%'] NAME assignment */
-        adjuststack(ls, left);  /* remove eventual 'garbage' left on stack */
-      }
-      return 1;
-    }
-
-    case RETURN: case ';': case ELSE: case ELSEIF:
-    case END: case UNTIL: case EOS:  /* 'stat' follow */
-      return 0;
-
-    default:
-      luaX_error(ls, "<statement> expected");
-      return 0;  /* to avoid warnings */
-  }
+static int32 stat(LexState *ls) {
+	int32 line = ls->linenumber;  // may be needed for error messages
+	FuncState *fs = ls->fs;
+	switch (ls->token) {
+	case IF:
+		{  // stat -> IF ifpart END
+			next(ls);
+			ifpart(ls);
+			check_match(ls, END, IF, line);
+			return 1;
+		}
+	case WHILE:
+		{  // stat -> WHILE cond DO block END
+			TProtoFunc *f = fs->f;
+			int32 while_init = fs->pc;
+			int32 cond_end, cond_size;
+			next(ls);
+			cond_end = cond(ls);
+			check(ls, DO);
+			block(ls);
+			check_match(ls, END, WHILE, line);
+			cond_size = cond_end-while_init;
+			check_pc(fs, cond_size);
+			memcpy(f->code+fs->pc, f->code+while_init, cond_size);
+			luaO_memdown(f->code+while_init, f->code+cond_end, fs->pc-while_init);
+			while_init += JMPSIZE + fixJump(ls, while_init, JMP, fs->pc-cond_size);
+			fix_upjmp(ls, IFTUPJMP, while_init);
+			return 1;
+		}
+	case DO:
+		{  // stat -> DO block END
+			next(ls);
+			block(ls);
+			check_match(ls, END, DO, line);
+			return 1;
+		}
+	case REPEAT:
+		{  // stat -> REPEAT block UNTIL exp1
+			int32 repeat_init = fs->pc;
+			next(ls);
+			block(ls);
+			check_match(ls, UNTIL, REPEAT, line);
+			exp1(ls);
+			fix_upjmp(ls, IFFUPJMP, repeat_init);
+			deltastack(ls, -1);  // pops condition
+			return 1;
+		}
+	case FUNCTION:
+		{  // stat -> FUNCTION funcname body
+			int32 needself;
+			vardesc v;
+			if (ls->fs->prev)  // inside other function?
+				return 0;
+			check_debugline(ls);
+			next(ls);
+			needself = funcname(ls, &v);
+			body(ls, needself, line);
+			storevar(ls, &v);
+			return 1;
+		}
+	case LOCAL:
+		{  // stat -> LOCAL localnamelist decinit
+			listdesc d;
+			int32 nvars;
+			check_debugline(ls);
+			next(ls);
+			nvars = localnamelist(ls);
+			decinit(ls, &d);
+			ls->fs->nlocalvar += nvars;
+			adjust_mult_assign(ls, nvars, &d);
+			return 1;
+		}
+	case NAME:
+	case '%':
+		{  // stat -> func | ['%'] NAME assignment
+			vardesc v;
+			check_debugline(ls);
+			var_or_func(ls, &v);
+			if (v.k == VEXP) { // stat -> func
+				if (v.info == 0)  // is just an upper value?
+					luaX_error(ls, "syntax error");
+				close_exp(ls, v.info, 0);
+			} else {
+				int32 left = assignment(ls, &v, 1);  // stat -> ['%'] NAME assignment
+				adjuststack(ls, left);  // remove eventual 'garbage' left on stack
+			}
+			return 1;
+		}
+	case RETURN:
+	case ';':
+	case ELSE:
+	case ELSEIF:
+	case END:
+	case UNTIL:
+	case EOS:  // 'stat' follow
+		return 0;
+	default:
+		luaX_error(ls, "<statement> expected");
+		return 0;  // to avoid warnings
+	}
 }
 
-static int32 SaveWord (LexState *ls) {
-  int32 res = ls->fs->pc;
-  check_pc(ls->fs, JMPSIZE);
-  ls->fs->pc += JMPSIZE;  /* open space */
-  return res;
+static int32 SaveWord(LexState *ls) {
+	int32 res = ls->fs->pc;
+	check_pc(ls->fs, JMPSIZE);
+	ls->fs->pc += JMPSIZE;  // open space
+	return res;
 }
 
-static int32 SaveWordPop (LexState *ls) {
-  deltastack(ls, -1);  /* pop condition */
-  return SaveWord(ls);
+static int32 SaveWordPop(LexState *ls) {
+	deltastack(ls, -1);  // pop condition
+	return SaveWord(ls);
 }
 
-static int32 cond (LexState *ls) {
-  /* cond -> exp1 */
-  exp1(ls);
-  return SaveWordPop(ls);
+static int32 cond(LexState *ls) {
+	// cond -> exp1
+	exp1(ls);
+	return SaveWordPop(ls);
 }
 
-static void block (LexState *ls) {
-  /* block -> chunk */
-  FuncState *fs = ls->fs;
-  int32 nlocalvar = fs->nlocalvar;
-  chunk(ls);
-  adjuststack(ls, fs->nlocalvar - nlocalvar);
-  for (; fs->nlocalvar > nlocalvar; fs->nlocalvar--)
-    luaI_unregisterlocalvar(fs, ls->linenumber);
+static void block(LexState *ls) {
+	// block -> chunk
+	FuncState *fs = ls->fs;
+	int32 nlocalvar = fs->nlocalvar;
+	chunk(ls);
+	adjuststack(ls, fs->nlocalvar - nlocalvar);
+	for (; fs->nlocalvar > nlocalvar; fs->nlocalvar--)
+		luaI_unregisterlocalvar(fs, ls->linenumber);
 }
 
-static int32 funcname (LexState *ls, vardesc *v) {
-  /* funcname -> NAME [':' NAME | '.' NAME] */
-  int32 needself = 0;
-  singlevar(ls, checkname(ls), v, 0);
-  if (ls->token == ':' || ls->token == '.') {
-    needself = (ls->token == ':');
-    next(ls);
-    lua_pushvar(ls, v);
-    code_string(ls, checkname(ls));
-    v->k = VINDEXED;
-  }
-  return needself;
+static int32 funcname(LexState *ls, vardesc *v) {
+	// funcname -> NAME [':' NAME | '.' NAME]
+	int32 needself = 0;
+	singlevar(ls, checkname(ls), v, 0);
+	if (ls->token == ':' || ls->token == '.') {
+		needself = (ls->token == ':');
+		next(ls);
+		lua_pushvar(ls, v);
+		code_string(ls, checkname(ls));
+		v->k = VINDEXED;
+	}
+	return needself;
 }
 
-static void body (LexState *ls, int32 needself, int32 line) {
-  /* body ->  '(' parlist ')' chunk END */
-  FuncState newfs;
-  init_state(ls, &newfs, ls->fs->f->fileName);
-  newfs.f->lineDefined = line;
-  check(ls, '(');
-  if (needself)
-    add_localvar(ls, luaS_new("self"));
-  parlist(ls);
-  check(ls, ')');
-  chunk(ls);
-  check_match(ls, END, FUNCTION, line);
-  close_func(ls);
-  func_onstack(ls, &newfs);
+static void body(LexState *ls, int32 needself, int32 line) {
+	// body ->  '(' parlist ')' chunk END */
+	FuncState newfs;
+	init_state(ls, &newfs, ls->fs->f->fileName);
+	newfs.f->lineDefined = line;
+	check(ls, '(');
+	if (needself)
+		add_localvar(ls, luaS_new("self"));
+	parlist(ls);
+	check(ls, ')');
+	chunk(ls);
+	check_match(ls, END, FUNCTION, line);
+	close_func(ls);
+	func_onstack(ls, &newfs);
 }
 
-static void ifpart (LexState *ls) {
-  /* ifpart -> cond THEN block [ELSE block | ELSEIF ifpart] */
-  int32 c = cond(ls);
-  int32 e;
-  check(ls, THEN);
-  block(ls);
-  e = SaveWord(ls);
-  switch (ls->token) {
-    case ELSE:
-      next(ls);
-      block(ls);
-      break;
-
-    case ELSEIF:
-      next(ls);
-      ifpart(ls);
-      break;
-  }
-  codeIf(ls, c, e);
+static void ifpart(LexState *ls) {
+	// ifpart -> cond THEN block [ELSE block | ELSEIF ifpart]
+	int32 c = cond(ls);
+	int32 e;
+	check(ls, THEN);
+	block(ls);
+	e = SaveWord(ls);
+	switch (ls->token) {
+	case ELSE:
+		next(ls);
+		block(ls);
+		break;
+	case ELSEIF:
+		next(ls);
+		ifpart(ls);
+		break;
+	}
+	codeIf(ls, c, e);
 }
 
 static void ret (LexState *ls) {
-  /* ret -> [RETURN explist sc] */
-  if (ls->token == RETURN) {
-    listdesc e;
-    check_debugline(ls);
-    next(ls);
-    explist(ls, &e);
-    close_exp(ls, e.pc, MULT_RET);
-    code_oparg(ls, RETCODE, 0, ls->fs->nlocalvar, 0);
-    ls->fs->stacksize = ls->fs->nlocalvar;  /* removes all temp values */
-    optional(ls, ';');
-  }
+	// ret -> [RETURN explist sc]
+	if (ls->token == RETURN) {
+		listdesc e;
+		check_debugline(ls);
+		next(ls);
+		explist(ls, &e);
+		close_exp(ls, e.pc, MULT_RET);
+		code_oparg(ls, RETCODE, 0, ls->fs->nlocalvar, 0);
+		ls->fs->stacksize = ls->fs->nlocalvar;  // removes all temp values
+		optional(ls, ';');
+	}
 }
 
-
 /*
 ** For parsing expressions, we use a classic stack with priorities.
 ** Each binary operator is represented by its index in "binop" + FIRSTBIN
@@ -869,463 +806,448 @@
 */
 #define POW	13
 
-static int32 binop [] = {EQ, NE, '>', '<', LE, GE, CONC,
-                        '+', '-', '*', '/', '^', 0};
+static int32 binop [] = { EQ, NE, '>', '<', LE, GE, CONC, '+', '-', '*', '/', '^', 0 };
 
-static int32 priority [POW+1] =  {5, 5, 1, 1, 1, 1, 1, 1, 2, 3, 3, 4, 4, 6};
+static int32 priority [POW + 1] =  { 5, 5, 1, 1, 1, 1, 1, 1, 2, 3, 3, 4, 4, 6 };
 
-static OpCode opcodes [POW+1] = {NOTOP, MINUSOP, EQOP, NEQOP, GTOP, LTOP,
-  LEOP, GEOP, CONCOP, ADDOP, SUBOP, MULTOP, DIVOP, POWOP};
+static OpCode opcodes [POW + 1] = { NOTOP, MINUSOP, EQOP, NEQOP, GTOP, LTOP,
+	LEOP, GEOP, CONCOP, ADDOP, SUBOP, MULTOP, DIVOP, POWOP };
 
 #define MAXOPS	20
 
 typedef struct {
-  int32 ops[MAXOPS];
-  int32 top;
+	int32 ops[MAXOPS];
+	int32 top;
 } stack_op;
 
-
-static void exp1 (LexState *ls) {
-  vardesc v;
-  exp0(ls, &v);
-  lua_pushvar(ls, &v);
-  if (is_in(ls->token, expfollow) < 0)
-    luaX_error(ls, "ill formed expression");
+static void exp1(LexState *ls) {
+	vardesc v;
+	exp0(ls, &v);
+	lua_pushvar(ls, &v);
+	if (is_in(ls->token, expfollow) < 0)
+		luaX_error(ls, "ill formed expression");
 }
 
-
-static void exp0 (LexState *ls, vardesc *v) {
-  exp2(ls, v);
-  while (ls->token == AND || ls->token == OR) {
-    int32 is_and = (ls->token == AND);
-    int32 pc;
-    lua_pushvar(ls, v);
-    next(ls);
-    pc = SaveWordPop(ls);
-    exp2(ls, v);
-    lua_pushvar(ls, v);
-    fixJump(ls, pc, (is_and?ONFJMP:ONTJMP), ls->fs->pc);
-  }
+static void exp0(LexState *ls, vardesc *v) {
+	exp2(ls, v);
+	while (ls->token == AND || ls->token == OR) {
+		int32 is_and = (ls->token == AND);
+		int32 pc;
+		lua_pushvar(ls, v);
+		next(ls);
+		pc = SaveWordPop(ls);
+		exp2(ls, v);
+		lua_pushvar(ls, v);
+		fixJump(ls, pc, (is_and ? ONFJMP: ONTJMP), ls->fs->pc);
+	}
 }
 
-
-static void push (LexState *ls, stack_op *s, int32 op) {
-  if (s->top == MAXOPS)
-    luaX_error(ls, "expression too complex");
-  s->ops[s->top++] = op;
+static void push(LexState *ls, stack_op *s, int32 op) {
+	if (s->top == MAXOPS)
+		luaX_error(ls, "expression too complex");
+	s->ops[s->top++] = op;
 }
 
-
-static void prefix (LexState *ls, stack_op *s) {
-  while (ls->token == NOT || ls->token == '-') {
-    push(ls, s, ls->token==NOT?0:1);
-    next(ls);
-  }
+static void prefix(LexState *ls, stack_op *s) {
+	while (ls->token == NOT || ls->token == '-') {
+		push(ls, s, ls->token == NOT ? 0 : 1);
+		next(ls);
+	}
 }
 
 static void pop_to (LexState *ls, stack_op *s, int32 prio) {
-  int32 op;
-  while (s->top > 0 && priority[(op=s->ops[s->top-1])] >= prio) {
-    code_opcode(ls, opcodes[op], op<FIRSTBIN?0:-1);
-    s->top--;
-  }
+	int32 op;
+	while (s->top > 0 && priority[(op = s->ops[s->top - 1])] >= prio) {
+		code_opcode(ls, opcodes[op], op < FIRSTBIN ? 0: -1);
+		s->top--;
+	}
 }
 
 static void exp2 (LexState *ls, vardesc *v) {
-  stack_op s;
-  int32 op;
-  s.top = 0;
-  prefix(ls, &s);
-  simpleexp(ls, v);
-  while ((op = is_in(ls->token, binop)) >= 0) {
-    op += FIRSTBIN;
-    lua_pushvar(ls, v);
-    /* '^' is right associative, so must 'simulate' a higher priority */
-    pop_to(ls, &s, (op == POW)?priority[op]+1:priority[op]);
-    push(ls, &s, op);
-    next(ls);
-    prefix(ls, &s);
-    simpleexp(ls, v);
-    lua_pushvar(ls, v);
-  }
-  if (s.top > 0) {
-    lua_pushvar(ls, v);
-    pop_to(ls, &s, 0);
-  }
+	stack_op s;
+	int32 op;
+	s.top = 0;
+	prefix(ls, &s);
+	simpleexp(ls, v);
+	while ((op = is_in(ls->token, binop)) >= 0) {
+		op += FIRSTBIN;
+		lua_pushvar(ls, v);
+		// '^' is right associative, so must 'simulate' a higher priority
+		pop_to(ls, &s, (op == POW) ? priority[op] + 1 : priority[op]);
+		push(ls, &s, op);
+		next(ls);
+		prefix(ls, &s);
+		simpleexp(ls, v);
+		lua_pushvar(ls, v);
+	}
+	if (s.top > 0) {
+		lua_pushvar(ls, v);
+		pop_to(ls, &s, 0);
+	}
 }
 
-
-static void simpleexp (LexState *ls, vardesc *v) {
-  check_debugline(ls);
-  switch (ls->token) {
-    case '(':  /* simpleexp -> '(' exp0 ')' */
-      next(ls);
-      exp0(ls, v);
-      check(ls, ')');
-      break;
-
-    case NUMBER:  /* simpleexp -> NUMBER */
-      code_number(ls, ls->seminfo.r);
-      next(ls);
-      v->k = VEXP; v->info = 0;
-      break;
-
-    case STRING:  /* simpleexp -> STRING */
-      code_string(ls, ls->seminfo.ts);
-      next(ls);
-      v->k = VEXP; v->info = 0;
-      break;
-
-    case NIL:  /* simpleexp -> NIL */
-      adjuststack(ls, -1);
-      next(ls);
-      v->k = VEXP; v->info = 0;
-      break;
-
-    case '{':  /* simpleexp -> constructor */
-      constructor(ls);
-      v->k = VEXP; v->info = 0;
-      break;
-
-    case FUNCTION: {  /* simpleexp -> FUNCTION body */
-      int32 line = ls->linenumber;
-      next(ls);
-      body(ls, 0, line);
-      v->k = VEXP; v->info = 0;
-      break;
-    }
-
-    case NAME: case '%':
-      var_or_func(ls, v);
-      break;
-
-    default:
-      luaX_error(ls, "<expression> expected");
-      break;
-  }
+static void simpleexp(LexState *ls, vardesc *v) {
+	check_debugline(ls);
+	switch (ls->token) {
+	case '(':  // simpleexp -> '(' exp0 ')'
+		next(ls);
+		exp0(ls, v);
+		check(ls, ')');
+		break;
+	case NUMBER:  // simpleexp -> NUMBER
+		code_number(ls, ls->seminfo.r);
+		next(ls);
+		v->k = VEXP;
+		v->info = 0;
+		break;
+	case STRING:  // simpleexp -> STRING
+		code_string(ls, ls->seminfo.ts);
+		next(ls);
+		v->k = VEXP;
+		v->info = 0;
+		break;
+	case NIL:  // simpleexp -> NIL
+		adjuststack(ls, -1);
+		next(ls);
+		v->k = VEXP;
+		v->info = 0;
+		break;
+	case '{':  // simpleexp -> constructor
+		constructor(ls);
+		v->k = VEXP;
+		v->info = 0;
+		break;
+	case FUNCTION:
+		{  // simpleexp -> FUNCTION body
+			int32 line = ls->linenumber;
+			next(ls);
+			body(ls, 0, line);
+			v->k = VEXP; v->info = 0;
+			break;
+		}
+	case NAME:
+	case '%':
+		var_or_func(ls, v);
+		break;
+	default:
+		luaX_error(ls, "<expression> expected");
+		break;
+	}
 }
 
-static void var_or_func (LexState *ls, vardesc *v) {
-  /* var_or_func -> ['%'] NAME var_or_func_tail */
-  if (optional(ls, '%')) {  /* upvalue? */
-    pushupvalue(ls, checkname(ls));
-    v->k = VEXP;
-    v->info = 0;  /* closed expression */
-  }
-  else  /* variable name */
-    singlevar(ls, checkname(ls), v, 0);
-  var_or_func_tail(ls, v);
+static void var_or_func(LexState *ls, vardesc *v) {
+	// var_or_func -> ['%'] NAME var_or_func_tail
+	if (optional(ls, '%')) {  // upvalue?
+		pushupvalue(ls, checkname(ls));
+		v->k = VEXP;
+		v->info = 0;  // closed expression
+	} else  // variable name
+		singlevar(ls, checkname(ls), v, 0);
+	var_or_func_tail(ls, v);
 }
 
-static void var_or_func_tail (LexState *ls, vardesc *v) {
-  for (;;) {
-    switch (ls->token) {
-      case '.':  /* var_or_func_tail -> '.' NAME */
-        next(ls);
-        lua_pushvar(ls, v);  /* 'v' must be on stack */
-        v->k = VDOT;
-        v->info = string_constant(ls->fs, checkname(ls));
-        break;
-
-      case '[':  /* var_or_func_tail -> '[' exp1 ']' */
-        next(ls);
-        lua_pushvar(ls, v);  /* 'v' must be on stack */
-        exp1(ls);
-        check(ls, ']');
-        v->k = VINDEXED;
-        break;
-
-      case ':':  /* var_or_func_tail -> ':' NAME funcparams */
-        next(ls);
-        lua_pushvar(ls, v);  /* 'v' must be on stack */
-        code_oparg(ls, PUSHSELF, 8, string_constant(ls->fs, checkname(ls)), 1);
-        v->k = VEXP;
-        v->info = funcparams(ls, 1);
-        break;
-
-      case '(': case STRING: case '{':  /* var_or_func_tail -> funcparams */
-        lua_pushvar(ls, v);  /* 'v' must be on stack */
-        v->k = VEXP;
-        v->info = funcparams(ls, 0);
-        break;
-
-      default: return;  /* should be follow... */
-    }
-  }
+static void var_or_func_tail(LexState *ls, vardesc *v) {
+	for (;;) {
+		switch (ls->token) {
+		case '.':  // var_or_func_tail -> '.' NAME
+			next(ls);
+			lua_pushvar(ls, v);  // 'v' must be on stack
+			v->k = VDOT;
+			v->info = string_constant(ls->fs, checkname(ls));
+			break;
+		case '[':  // var_or_func_tail -> '[' exp1 ']'
+			next(ls);
+			lua_pushvar(ls, v);  // 'v' must be on stack
+			exp1(ls);
+			check(ls, ']');
+			v->k = VINDEXED;
+			break;
+		case ':':  // var_or_func_tail -> ':' NAME funcparams
+			next(ls);
+			lua_pushvar(ls, v);  // 'v' must be on stack
+			code_oparg(ls, PUSHSELF, 8, string_constant(ls->fs, checkname(ls)), 1);
+			v->k = VEXP;
+			v->info = funcparams(ls, 1);
+			break;
+		case '(':
+		case STRING:
+		case '{':  // var_or_func_tail -> funcparams
+			lua_pushvar(ls, v);  // 'v' must be on stack
+			v->k = VEXP;
+			v->info = funcparams(ls, 0);
+			break;
+		default:
+		  return;  // should be follow...
+		}
+	}
 }
 
-static int32 funcparams (LexState *ls, int32 slf) {
-  FuncState *fs = ls->fs;
-  int32 nparams = 1;  /* default value */
-  switch (ls->token) {
-    case '(': {  /* funcparams -> '(' explist ')' */
-      listdesc e;
-      next(ls);
-      explist(ls, &e);
-      check(ls, ')');
-      close_exp(ls, e.pc, 1);
-      nparams = e.n;
-      break;
-    }
+static int32 funcparams(LexState *ls, int32 slf) {
+	FuncState *fs = ls->fs;
+	int32 nparams = 1;  // default value
+	switch (ls->token) {
+	case '(':
+		{  // funcparams -> '(' explist ')'
+			listdesc e;
+			next(ls);
+			explist(ls, &e);
+			check(ls, ')');
+			close_exp(ls, e.pc, 1);
+			nparams = e.n;
+			break;
+		}
+	case '{':  // funcparams -> constructor
+		constructor(ls);
+		break;
+	case STRING:  // funcparams -> STRING
+		code_string(ls, ls->seminfo.ts);
+		next(ls);
+		break;
+	default:
+		luaX_error(ls, "function arguments expected");
+		break;
+	}
+	code_byte(fs, 0);  // save space for opcode
+	code_byte(fs, 0);  // and nresult
+	code_byte(fs, nparams + slf);
 
-    case '{':  /* funcparams -> constructor */
-      constructor(ls);
-      break;
-
-    case STRING:  /* funcparams -> STRING */
-      code_string(ls, ls->seminfo.ts);
-      next(ls);
-      break;
-
-    default:
-      luaX_error(ls, "function arguments expected");
-      break;
-  }
-  code_byte(fs, 0);  /* save space for opcode */
-  code_byte(fs, 0);  /* and nresult */
-  code_byte(fs, nparams+slf);
-  return fs->pc-1;
+	return fs->pc - 1;
 }
 
-static void explist (LexState *ls, listdesc *d) {
-  switch (ls->token) {
-    case ELSE: case ELSEIF: case END: case UNTIL:
-    case EOS: case ';': case ')':
-      d->pc = 0;
-      d->n = 0;
-      break;
-
-    default:
-      explist1(ls, d);
-  }
+static void explist(LexState *ls, listdesc *d) {
+	switch (ls->token) {
+	case ELSE:
+	case ELSEIF:
+	case END:
+	case UNTIL:
+	case EOS:
+	case ';':
+	case ')':
+		d->pc = 0;
+		d->n = 0;
+		break;
+	default:
+		explist1(ls, d);
+	}
 }
 
-static void explist1 (LexState *ls, listdesc *d) {
-  vardesc v;
-  exp0(ls, &v);
-  d->n = 1;
-  while (ls->token == ',') {
-    d->n++;
-    lua_pushvar(ls, &v);
-    next(ls);
-    exp0(ls, &v);
-  }
-  if (v.k == VEXP)
-    d->pc = v.info;
-  else {
-    lua_pushvar(ls, &v);
-    d->pc = 0;
-  }
+static void explist1(LexState *ls, listdesc *d) {
+	vardesc v;
+	exp0(ls, &v);
+	d->n = 1;
+	while (ls->token == ',') {
+		d->n++;
+		lua_pushvar(ls, &v);
+		next(ls);
+		exp0(ls, &v);
+	}
+	if (v.k == VEXP)
+		d->pc = v.info;
+	else {
+		lua_pushvar(ls, &v);
+		d->pc = 0;
+	}
 }
 
 static void parlist (LexState *ls) {
-  int32 nparams = 0;
-  int32 dots = 0;
-  switch (ls->token) {
-    case DOTS:  /* parlist -> DOTS */
-      next(ls);
-      dots = 1;
-      break;
-
-    case NAME:  /* parlist, tailparlist -> NAME [',' tailparlist] */
-      init:
-      store_localvar(ls, checkname(ls), nparams++);
-      if (ls->token == ',') {
-        next(ls);
-        switch (ls->token) {
-          case DOTS:  /* tailparlist -> DOTS */
-            next(ls);
-            dots = 1;
-            break;
-
-          case NAME:  /* tailparlist -> NAME [',' tailparlist] */
-            goto init;
-
-          default: luaX_error(ls, "NAME or `...' expected");
-        }
-      }
-      break;
-
-    case ')': break;  /* parlist -> empty */
-
-    default: luaX_error(ls, "NAME or `...' expected");
-  }
-  code_args(ls, nparams, dots);
+	int32 nparams = 0;
+	int32 dots = 0;
+	switch (ls->token) {
+	case DOTS:  // parlist -> DOTS
+		next(ls);
+		dots = 1;
+		break;
+	case NAME:  // parlist, tailparlist -> NAME [',' tailparlist]
+init:
+		store_localvar(ls, checkname(ls), nparams++);
+		if (ls->token == ',') {
+			next(ls);
+			switch (ls->token) {
+			case DOTS:  // tailparlist -> DOTS
+				next(ls);
+				dots = 1;
+				break;
+			case NAME:  // tailparlist -> NAME [',' tailparlist]
+				goto init;
+			default: luaX_error(ls, "NAME or `...' expected");
+			}
+		}
+		break;
+	case ')':
+		break;  // parlist -> empty
+	default:
+		luaX_error(ls, "NAME or `...' expected");
+	}
+	code_args(ls, nparams, dots);
 }
 
 static int32 localnamelist (LexState *ls) {
-  /* localnamelist -> NAME {',' NAME} */
-  int32 i = 1;
-  store_localvar(ls, checkname(ls), 0);
-  while (ls->token == ',') {
-    next(ls);
-    store_localvar(ls, checkname(ls), i++);
-  }
-  return i;
+	// localnamelist -> NAME {',' NAME}
+	int32 i = 1;
+	store_localvar(ls, checkname(ls), 0);
+	while (ls->token == ',') {
+		next(ls);
+		store_localvar(ls, checkname(ls), i++);
+	}
+	return i;
 }
 
 static void decinit (LexState *ls, listdesc *d) {
-  /* decinit -> ['=' explist1] */
-  if (ls->token == '=') {
-    next(ls);
-    explist1(ls, d);
-  }
-  else {
-    d->n = 0;
-    d->pc = 0;
-  }
+	// decinit -> ['=' explist1]
+	if (ls->token == '=') {
+		next(ls);
+		explist1(ls, d);
+	} else {
+		d->n = 0;
+		d->pc = 0;
+	}
 }
 
 static int32 assignment (LexState *ls, vardesc *v, int32 nvars) {
-  int32 left = 0;
-  /* dotted variables <a.x> must be stored like regular indexed vars <a["x"]> */
-  if (v->k == VDOT) {
-    code_constant(ls, v->info);
-    v->k = VINDEXED;
-  }
-  if (ls->token == ',') {  /* assignment -> ',' NAME assignment */
-    vardesc nv;
-    next(ls);
-    var_or_func(ls, &nv);
-    if (nv.k == VEXP)
-      luaX_error(ls, "syntax error");
-    left = assignment(ls, &nv, nvars+1);
-  }
-  else {  /* assignment -> '=' explist1 */
-    listdesc d;
-    check(ls, '=');
-    explist1(ls, &d);
-    adjust_mult_assign(ls, nvars, &d);
-  }
-  if (v->k != VINDEXED || left+(nvars-1) == 0) {
-    /* global/local var or indexed var without values in between */
-    storevar(ls, v);
-  }
-  else {  /* indexed var with values in between*/
-    code_oparg(ls, SETTABLE, 0, left+(nvars-1), -1);
-    left += 2;  /* table/index are not popped, because they aren't on top */
-  }
-  return left;
+	int32 left = 0;
+	// dotted variables <a.x> must be stored like regular indexed vars <a["x"]>
+	if (v->k == VDOT) {
+		code_constant(ls, v->info);
+		v->k = VINDEXED;
+	}
+	if (ls->token == ',') {  // assignment -> ',' NAME assignment
+		vardesc nv;
+		next(ls);
+		var_or_func(ls, &nv);
+		if (nv.k == VEXP)
+			luaX_error(ls, "syntax error");
+		left = assignment(ls, &nv, nvars + 1);
+	} else {  // assignment -> '=' explist1
+		listdesc d;
+		check(ls, '=');
+		explist1(ls, &d);
+		adjust_mult_assign(ls, nvars, &d);
+	}
+	if (v->k != VINDEXED || left+(nvars-1) == 0) {
+		// global/local var or indexed var without values in between
+		storevar(ls, v);
+	} else {  // indexed var with values in between
+		code_oparg(ls, SETTABLE, 0, left+(nvars-1), -1);
+		left += 2;  // table/index are not popped, because they aren't on top
+	}
+	return left;
 }
 
-static void constructor (LexState *ls) {
-  /* constructor -> '{' part [';' part] '}' */
-  int32 line = ls->linenumber;
-  int32 pc = SaveWord(ls);
-  int32 nelems;
-  constdesc cd;
-  deltastack(ls, 1);
-  check(ls, '{');
-  part(ls, &cd);
-  nelems = cd.n;
-  if (ls->token == ';') {
-    constdesc other_cd;
-    next(ls);
-    part(ls, &other_cd);
-    if (cd.k == other_cd.k)  /* repeated parts? */
-      luaX_error(ls, "invalid constructor syntax");
-    nelems += other_cd.n;
-  }
-  check_match(ls, '}', '{', line);
-  fix_opcode(ls, pc, CREATEARRAY, 2, nelems);
+static void constructor(LexState *ls) {
+	// constructor -> '{' part [';' part] '}'
+	int32 line = ls->linenumber;
+	int32 pc = SaveWord(ls);
+	int32 nelems;
+	constdesc cd;
+	deltastack(ls, 1);
+	check(ls, '{');
+	part(ls, &cd);
+	nelems = cd.n;
+	if (ls->token == ';') {
+		constdesc other_cd;
+		next(ls);
+		part(ls, &other_cd);
+		if (cd.k == other_cd.k)  // repeated parts?
+			luaX_error(ls, "invalid constructor syntax");
+		nelems += other_cd.n;
+	}
+	check_match(ls, '}', '{', line);
+	fix_opcode(ls, pc, CREATEARRAY, 2, nelems);
 }
 
-static void part (LexState *ls, constdesc *cd) {
-  switch (ls->token) {
-    case ';': case '}':  /* part -> empty */
-      cd->n = 0;
-      cd->k = ls->token;
-      return;
+static void part(LexState *ls, constdesc *cd) {
+	switch (ls->token) {
+	case ';':
+	case '}':  // part -> empty
+		cd->n = 0;
+		cd->k = ls->token;
+		return;
+	case NAME:
+		{
+			vardesc v;
+			exp0(ls, &v);
+			if (ls->token == '=') {
+				switch (v.k) {
+				case VGLOBAL:
+					code_constant(ls, v.info);
+				break;
+				case VLOCAL:
+					code_string(ls, ls->fs->localvar[v.info]);
+				break;
+				default:
+					luaX_error(ls, "`=' unexpected");
+				}
+				next(ls);
+				exp1(ls);
+				cd->n = recfields(ls);
+				cd->k = 1;  // record
+			} else {
+				lua_pushvar(ls, &v);
+				cd->n = listfields(ls);
+				cd->k = 0;  // list
+			}
+			break;
+		}
 
-    case NAME: {
-      vardesc v;
-      exp0(ls, &v);
-      if (ls->token == '=') {
-        switch (v.k) {
-          case VGLOBAL:
-            code_constant(ls, v.info);
-            break;
-          case VLOCAL:
-            code_string(ls, ls->fs->localvar[v.info]);
-            break;
-          default:
-            luaX_error(ls, "`=' unexpected");
-        }
-        next(ls);
-        exp1(ls);
-        cd->n = recfields(ls);
-        cd->k = 1;  /* record */
-      }
-      else {
-        lua_pushvar(ls, &v);
-        cd->n = listfields(ls);
-        cd->k = 0;  /* list */
-      }
-      break;
-    }
-
-    case '[':  /* part -> recfield recfields */
-      recfield(ls);
-      cd->n = recfields(ls);
-      cd->k = 1;  /* record */
-      break;
-
-    default:  /* part -> exp1 listfields */
-      exp1(ls);
-      cd->n = listfields(ls);
-      cd->k = 0;  /* list */
-      break;
-  }
+		case '[':  // part -> recfield recfields
+			recfield(ls);
+			cd->n = recfields(ls);
+			cd->k = 1;  // record
+		break;
+		default:  // part -> exp1 listfields
+			exp1(ls);
+			cd->n = listfields(ls);
+			cd->k = 0;  // list
+		break;
+	}
 }
 
-static int32 recfields (LexState *ls) {
-  /* recfields -> { ',' recfield } [','] */
-  int32 n = 1;  /* one has been read before */
-  while (ls->token == ',') {
-    next(ls);
-    if (ls->token == ';' || ls->token == '}')
-      break;
-    recfield(ls);
-    n++;
-    if (n%RFIELDS_PER_FLUSH == 0)
-      flush_record(ls, RFIELDS_PER_FLUSH);
-  }
-  flush_record(ls, n%RFIELDS_PER_FLUSH);
-  return n;
+static int32 recfields(LexState *ls) {
+	// recfields -> { ',' recfield } [',']
+	int32 n = 1;  // one has been read before
+	while (ls->token == ',') {
+		next(ls);
+		if (ls->token == ';' || ls->token == '}')
+			break;
+		recfield(ls);
+		n++;
+		if (n % RFIELDS_PER_FLUSH == 0)
+			flush_record(ls, RFIELDS_PER_FLUSH);
+	}
+	flush_record(ls, n % RFIELDS_PER_FLUSH);
+	return n;
 }
 
-static int32 listfields (LexState *ls) {
-  /* listfields -> { ',' exp1 } [','] */
-  int32 n = 1;  /* one has been read before */
-  while (ls->token == ',') {
-    next(ls);
-    if (ls->token == ';' || ls->token == '}')
-      break;
-    exp1(ls);
-    n++;
-    if (n%LFIELDS_PER_FLUSH == 0)
-      flush_list(ls, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH);
-  }
-  flush_list(ls, n/LFIELDS_PER_FLUSH, n%LFIELDS_PER_FLUSH);
-  return n;
+static int32 listfields(LexState *ls) {
+	// listfields -> { ',' exp1 } [',']
+	int32 n = 1;  // one has been read before
+	while (ls->token == ',') {
+		next(ls);
+		if (ls->token == ';' || ls->token == '}')
+			break;
+		exp1(ls);
+		n++;
+		if (n % LFIELDS_PER_FLUSH == 0)
+			flush_list(ls, n / LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH);
+	}
+	flush_list(ls, n / LFIELDS_PER_FLUSH, n % LFIELDS_PER_FLUSH);
+	return n;
 }
 
-static void recfield (LexState *ls) {
-  /* recfield -> (NAME | '['exp1']') = exp1 */
-  switch (ls->token) {
-    case NAME:
-      code_string(ls, checkname(ls));
-      break;
-
-    case '[':
-      next(ls);
-      exp1(ls);
-      check(ls, ']');
-      break;
-
-    default: luaX_error(ls, "NAME or `[' expected");
-  }
-  check(ls, '=');
-  exp1(ls);
+static void recfield(LexState *ls) {
+	// recfield -> (NAME | '['exp1']') = exp1
+	switch (ls->token) {
+	case NAME:
+		code_string(ls, checkname(ls));
+		break;
+	case '[':
+		next(ls);
+		exp1(ls);
+		check(ls, ']');
+		break;
+	default:
+		luaX_error(ls, "NAME or `[' expected");
+	}
+	check(ls, '=');
+	exp1(ls);
 }
-

Modified: residual/trunk/engine/lua/lparser.h
===================================================================
--- residual/trunk/engine/lua/lparser.h	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lparser.h	2008-07-29 14:57:13 UTC (rev 33411)
@@ -10,11 +10,9 @@
 #include "lobject.h"
 #include "lzio.h"
 
+void luaY_codedebugline(int32 line);
+TProtoFunc *luaY_parser(ZIO *z);
+void luaY_error(char *s);
+void luaY_syntaxerror(char *s, char *token);
 
-void luaY_codedebugline (int32 line);
-TProtoFunc *luaY_parser (ZIO *z);
-void luaY_error (char *s);
-void luaY_syntaxerror (char *s, char *token);
-
-
 #endif

Modified: residual/trunk/engine/lua/lrestore.cpp
===================================================================
--- residual/trunk/engine/lua/lrestore.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lrestore.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -1,13 +1,13 @@
-#include "ltask.h"
-#include "lauxlib.h"
-#include "lmem.h"
-#include "ldo.h"
-#include "ltm.h"
-#include "ltable.h"
-#include "lvm.h"
-#include "lopcodes.h"
-#include "lstring.h"
-#include "lua.h"
+#include "engine/lua/ltask.h"
+#include "engine/lua/lauxlib.h"
+#include "engine/lua/lmem.h"
+#include "engine/lua/ldo.h"
+#include "engine/lua/ltm.h"
+#include "engine/lua/ltable.h"
+#include "engine/lua/lvm.h"
+#include "engine/lua/lopcodes.h"
+#include "engine/lua/lstring.h"
+#include "engine/lua/lua.h"
 
 #include "common/endian.h"
 
@@ -366,7 +366,7 @@
 		}
 
 		int32 codeSize = restoreSint32();
-		tempProtoFunc->code = (lua_Byte *)luaM_malloc(codeSize);
+		tempProtoFunc->code = (byte *)luaM_malloc(codeSize);
 		restoreStream(tempProtoFunc->code, codeSize);
 		arraysObj->object = tempProtoFunc;
 		arraysObj++;

Modified: residual/trunk/engine/lua/lsave.cpp
===================================================================
--- residual/trunk/engine/lua/lsave.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lsave.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -1,13 +1,13 @@
-#include "ltask.h"
-#include "lauxlib.h"
-#include "lmem.h"
-#include "ldo.h"
-#include "ltm.h"
-#include "ltable.h"
-#include "lvm.h"
-#include "lopcodes.h"
-#include "lstring.h"
-#include "lua.h"
+#include "engine/lua/ltask.h"
+#include "engine/lua/lauxlib.h"
+#include "engine/lua/lmem.h"
+#include "engine/lua/ldo.h"
+#include "engine/lua/ltm.h"
+#include "engine/lua/ltable.h"
+#include "engine/lua/lvm.h"
+#include "engine/lua/lopcodes.h"
+#include "engine/lua/lstring.h"
+#include "engine/lua/lua.h"
 
 #include "common/endian.h"
 
@@ -307,8 +307,8 @@
 			saveSint32(tempProtoFunc->locvars[i].line);
 		}
 
-		Byte *codePtr = tempProtoFunc->code + 2;
-		Byte *tmpPtr = codePtr;
+		byte *codePtr = tempProtoFunc->code + 2;
+		byte *tmpPtr = codePtr;
 		int32 opcodeId;
 		do {
 			opcodeId = *tmpPtr;

Modified: residual/trunk/engine/lua/lstate.cpp
===================================================================
--- residual/trunk/engine/lua/lstate.cpp	2008-07-29 13:46:42 UTC (rev 33410)
+++ residual/trunk/engine/lua/lstate.cpp	2008-07-29 14:57:13 UTC (rev 33411)
@@ -5,20 +5,19 @@
 */
 
 
-#include "lbuiltin.h"
-#include "ldo.h"
-#include "lauxlib.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltask.h"
-#include "ltm.h"
+#include "engine/lua/lbuiltin.h"
+#include "engine/lua/ldo.h"
+#include "engine/lua/lauxlib.h"
+#include "engine/lua/lfunc.h"

@@ Diff output truncated at 100000 characters. @@

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




More information about the Scummvm-git-logs mailing list