[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