[Scummvm-cvs-logs] SF.net SVN: scummvm:[33378] residual/trunk/engine/lua
aquadran at users.sourceforge.net
aquadran at users.sourceforge.net
Mon Jul 28 16:51:58 CEST 2008
Revision: 33378
http://scummvm.svn.sourceforge.net/scummvm/?rev=33378&view=rev
Author: aquadran
Date: 2008-07-28 14:51:57 +0000 (Mon, 28 Jul 2008)
Log Message:
-----------
remove dofile,
formating code
Modified Paths:
--------------
residual/trunk/engine/lua/lbuiltin.cpp
residual/trunk/engine/lua/ldo.cpp
residual/trunk/engine/lua/ldo.h
residual/trunk/engine/lua/lua.h
residual/trunk/engine/lua/lundump.cpp
residual/trunk/engine/lua/lzio.cpp
residual/trunk/engine/lua/lzio.h
Modified: residual/trunk/engine/lua/lbuiltin.cpp
===================================================================
--- residual/trunk/engine/lua/lbuiltin.cpp 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/lbuiltin.cpp 2008-07-28 14:51:57 UTC (rev 33378)
@@ -122,16 +122,6 @@
lua_pushuserdata(NULL); /* at least one result to signal no errors */
}
-
-static void internaldofile (void)
-{
- const char *fname = luaL_opt_string(1, NULL);
- if (lua_dofile(fname) == 0)
- if (luaA_passresults() == 0)
- lua_pushuserdata(NULL); /* at least one result to signal no errors */
-}
-
-
static void to_string (void) {
lua_Object obj = lua_getparam(1);
char *buff = luaL_openspace(30);
@@ -485,7 +475,6 @@
{"assert", luaI_assert},
{"call", luaI_call},
{"collectgarbage", luaI_collectgarbage},
- {"dofile", internaldofile},
{"copytagmethods", copytagmethods},
{"dostring", internaldostring},
{"error", luaI_error},
Modified: residual/trunk/engine/lua/ldo.cpp
===================================================================
--- residual/trunk/engine/lua/ldo.cpp 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/ldo.cpp 2008-07-28 14:51:57 UTC (rev 33378)
@@ -5,272 +5,241 @@
*/
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "ltask.h"
-#include "ltm.h"
-#include "lua.h"
-#include "luadebug.h"
-#include "lundump.h"
-#include "lvm.h"
-#include "lzio.h"
+#include "engine/lua/ldo.h"
+#include "engine/lua/lfunc.h"
+#include "engine/lua/lgc.h"
+#include "engine/lua/lmem.h"
+#include "engine/lua/lobject.h"
+#include "engine/lua/lopcodes.h"
+#include "engine/lua/lparser.h"
+#include "engine/lua/lstate.h"
+#include "engine/lua/ltask.h"
+#include "engine/lua/ltm.h"
+#include "engine/lua/lua.h"
+#include "engine/lua/luadebug.h"
+#include "engine/lua/lundump.h"
+#include "engine/lua/lvm.h"
+#include "engine/lua/lzio.h"
+#include "common/file.h"
-
#ifndef STACK_LIMIT
#define STACK_LIMIT 6000
#endif
-
-
-/* Extra stack size to run a function: LUA_T_LINE(1), TM calls(2), ... */
+// Extra stack size to run a function: LUA_T_LINE(1), TM calls(2), ...
#define EXTRA_STACK 5
-
/*
** Error messages
*/
-void stderrorim (void)
-{
- fprintf(stderr, "lua error: %s\n", lua_getstring(lua_getparam(1)));
+void stderrorim() {
+ fprintf(stderr, "lua error: %s\n", lua_getstring(lua_getparam(1)));
}
-
-
#define STACK_UNIT 128
-/* Initial size for CallInfo array */
+// Initial size for CallInfo array
#define BASIC_CI_SIZE 8
-void luaD_init (void)
-{
- ttype(&L->errorim) = LUA_T_CPROTO;
- fvalue(&L->errorim) = stderrorim;
+void luaD_init() {
+ ttype(&L->errorim) = LUA_T_CPROTO;
+ fvalue(&L->errorim) = stderrorim;
}
-void luaD_initthr (void)
-{
- L->stack.stack = luaM_newvector(STACK_UNIT, TObject);
- L->stack.top = L->stack.stack;
- L->stack.last = L->stack.stack+(STACK_UNIT-1);
- L->base_ci = luaM_newvector(BASIC_CI_SIZE, struct CallInfo);
- memset(L->base_ci, 0, sizeof(CallInfo) * BASIC_CI_SIZE);
- L->base_ci_size = sizeof(CallInfo) * BASIC_CI_SIZE;
- L->ci = L->base_ci;
- L->ci->tf = NULL;
- L->end_ci = L->base_ci + BASIC_CI_SIZE;
+void luaD_initthr() {
+ L->stack.stack = luaM_newvector(STACK_UNIT, TObject);
+ L->stack.top = L->stack.stack;
+ L->stack.last = L->stack.stack + (STACK_UNIT - 1);
+ L->base_ci = luaM_newvector(BASIC_CI_SIZE, struct CallInfo);
+ memset(L->base_ci, 0, sizeof(CallInfo) * BASIC_CI_SIZE);
+ L->base_ci_size = sizeof(CallInfo) * BASIC_CI_SIZE;
+ L->ci = L->base_ci;
+ L->ci->tf = NULL;
+ L->end_ci = L->base_ci + BASIC_CI_SIZE;
}
-
-void luaD_checkstack (int32 n)
-{
- struct Stack *S = &L->stack;
- if (S->last-S->top <= n) {
- StkId top = S->top-S->stack;
- int32 stacksize = (S->last-S->stack)+1+STACK_UNIT+n;
- S->stack = luaM_reallocvector(S->stack, stacksize, TObject);
- S->last = S->stack+(stacksize-1);
- S->top = S->stack + top;
- if (stacksize >= STACK_LIMIT) { /* stack overflow? */
- if (lua_stackedfunction(100) == LUA_NOOBJECT) /* 100 funcs on stack? */
- lua_error("Lua2C - C2Lua overflow"); /* doesn't look like a rec. loop */
- else
- lua_error("stack size overflow");
- }
- }
+void luaD_checkstack(int32 n) {
+ struct Stack *S = &L->stack;
+ if (S->last-S->top <= n) {
+ StkId top = S->top-S->stack;
+ int32 stacksize = (S->last-S->stack) + 1 + STACK_UNIT + n;
+ S->stack = luaM_reallocvector(S->stack, stacksize, TObject);
+ S->last = S->stack + (stacksize - 1);
+ S->top = S->stack + top;
+ if (stacksize >= STACK_LIMIT) { // stack overflow?
+ if (lua_stackedfunction(100) == LUA_NOOBJECT) // 100 funcs on stack?
+ lua_error("Lua2C - C2Lua overflow"); // doesn't look like a rec. loop
+ else
+ lua_error("stack size overflow");
+ }
+ }
}
-
/*
** Adjust stack. Set top to the given value, pushing NILs if needed.
*/
-void luaD_adjusttop (StkId newtop)
-{
- int32 diff = newtop-(L->stack.top-L->stack.stack);
- if (diff <= 0)
- L->stack.top += diff;
- else {
- luaD_checkstack(diff);
- while (diff--)
- ttype(L->stack.top++) = LUA_T_NIL;
- }
+void luaD_adjusttop(StkId newtop) {
+ int32 diff = newtop-(L->stack.top-L->stack.stack);
+ if (diff <= 0)
+ L->stack.top += diff;
+ else {
+ luaD_checkstack(diff);
+ while (diff--)
+ ttype(L->stack.top++) = LUA_T_NIL;
+ }
}
-
/*
** Open a hole below "nelems" from the L->stack.top.
*/
-void luaD_openstack (int32 nelems)
-{
- luaO_memup(L->stack.top-nelems+1, L->stack.top-nelems,
- nelems*sizeof(TObject));
- incr_top;
+void luaD_openstack(int32 nelems) {
+ luaO_memup(L->stack.top - nelems + 1, L->stack.top - nelems, nelems * sizeof(TObject));
+ incr_top;
}
-
-void luaD_lineHook (int32 line)
-{
- struct C_Lua_Stack oldCLS = L->Cstack;
- StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
- L->Cstack.num = 0;
- (*lua_linehook)(line);
- L->stack.top = L->stack.stack+old_top;
- L->Cstack = oldCLS;
+void luaD_lineHook(int32 line) {
+ struct C_Lua_Stack oldCLS = L->Cstack;
+ StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
+ L->Cstack.num = 0;
+ (*lua_linehook)(line);
+ L->stack.top = L->stack.stack + old_top;
+ L->Cstack = oldCLS;
}
-
-void luaD_callHook (StkId base, TProtoFunc *tf, int32 isreturn)
-{
- struct C_Lua_Stack oldCLS = L->Cstack;
- StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
- L->Cstack.num = 0;
- if (isreturn)
- (*lua_callhook)(LUA_NOOBJECT, "(return)", 0);
- else {
- TObject *f = L->stack.stack+base-1;
- if (tf)
- (*lua_callhook)(Ref(f), tf->fileName->str, tf->lineDefined);
- else
- (*lua_callhook)(Ref(f), "(C)", -1);
- }
- L->stack.top = L->stack.stack+old_top;
- L->Cstack = oldCLS;
+void luaD_callHook(StkId base, TProtoFunc *tf, int32 isreturn) {
+ struct C_Lua_Stack oldCLS = L->Cstack;
+ StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
+ L->Cstack.num = 0;
+ if (isreturn)
+ (*lua_callhook)(LUA_NOOBJECT, "(return)", 0);
+ else {
+ TObject *f = L->stack.stack + base - 1;
+ if (tf)
+ (*lua_callhook)(Ref(f), tf->fileName->str, tf->lineDefined);
+ else
+ (*lua_callhook)(Ref(f), "(C)", -1);
+ }
+ L->stack.top = L->stack.stack + old_top;
+ L->Cstack = oldCLS;
}
-
/*
** Call a C function.
** Cstack.num is the number of arguments; Cstack.lua2C points to the
** first argument. Returns an index to the first result from C.
*/
-static StkId callC (lua_CFunction f, StkId base)
-{
- struct C_Lua_Stack *CS = &L->Cstack;
- struct C_Lua_Stack oldCLS = *CS;
- StkId firstResult;
- int32 numarg = (L->stack.top-L->stack.stack) - base;
- CS->num = numarg;
- CS->lua2C = base;
- CS->base = base+numarg; /* == top-stack */
- if (lua_callhook)
- luaD_callHook(base, NULL, 0);
- (*f)(); /* do the actual call */
- if (lua_callhook) /* func may have changed lua_callhook */
- luaD_callHook(base, NULL, 1);
- firstResult = CS->base;
- *CS = oldCLS;
- return firstResult;
+static StkId callC(lua_CFunction f, StkId base) {
+ struct C_Lua_Stack *CS = &L->Cstack;
+ struct C_Lua_Stack oldCLS = *CS;
+ StkId firstResult;
+ int32 numarg = (L->stack.top-L->stack.stack) - base;
+ CS->num = numarg;
+ CS->lua2C = base;
+ CS->base = base + numarg; // == top - stack
+ if (lua_callhook)
+ luaD_callHook(base, NULL, 0);
+ (*f)(); // do the actual call
+ if (lua_callhook) // func may have changed lua_callhook
+ luaD_callHook(base, NULL, 1);
+ firstResult = CS->base;
+ *CS = oldCLS;
+ return firstResult;
}
-
-static StkId callCclosure (struct Closure *cl, lua_CFunction f, StkId base)
-{
- TObject *pbase;
- int32 nup = cl->nelems; /* number of upvalues */
- luaD_checkstack(nup);
- pbase = L->stack.stack+base; /* care: previous call may change this */
- /* open space for upvalues as extra arguments */
- luaO_memup(pbase+nup, pbase, (L->stack.top-pbase)*sizeof(TObject));
- /* copy upvalues into stack */
- memcpy(pbase, cl->consts+1, nup*sizeof(TObject));
- L->stack.top += nup;
- return callC(f, base);
+static StkId callCclosure(struct Closure *cl, lua_CFunction f, StkId base) {
+ TObject *pbase;
+ int32 nup = cl->nelems; // number of upvalues
+ luaD_checkstack(nup);
+ pbase = L->stack.stack + base; // care: previous call may change this
+ // open space for upvalues as extra arguments
+ luaO_memup(pbase+nup, pbase, (L->stack.top - pbase) * sizeof(TObject));
+ // copy upvalues into stack
+ memcpy(pbase, cl->consts + 1, nup * sizeof(TObject));
+ L->stack.top += nup;
+ return callC(f, base);
}
-
-void luaD_callTM (TObject *f, int32 nParams, int32 nResults)
-{
- luaD_openstack(nParams);
- *(L->stack.top-nParams-1) = *f;
- luaD_call((L->stack.top-L->stack.stack)-nParams, nResults);
+void luaD_callTM(TObject *f, int32 nParams, int32 nResults) {
+ luaD_openstack(nParams);
+ *(L->stack.top - nParams - 1) = *f;
+ luaD_call((L->stack.top - L->stack.stack) - nParams, nResults);
}
-static void adjust_varargs (StkId first_extra_arg)
-{
- TObject arg;
- luaV_pack(first_extra_arg,
- (L->stack.top-L->stack.stack)-first_extra_arg, &arg);
- luaD_adjusttop(first_extra_arg);
- *L->stack.top++ = arg;
+static void adjust_varargs(StkId first_extra_arg) {
+ TObject arg;
+ luaV_pack(first_extra_arg, (L->stack.top - L->stack.stack) - first_extra_arg, &arg);
+ luaD_adjusttop(first_extra_arg);
+ *L->stack.top++ = arg;
}
-
-
/*
** Prepare the stack for calling a Lua function.
*/
-void luaD_precall (TObject *f, StkId base, int32 nResults)
-{
- /* Create a new CallInfo record */
- if (L->ci+1 == L->end_ci) {
- int32 size_ci = L->end_ci - L->base_ci;
- int32 index_ci = L->ci - L->base_ci;
- int32 new_ci_size = size_ci * 2 * sizeof(CallInfo);
- CallInfo *new_ci = (CallInfo *)luaM_malloc(new_ci_size);
- memcpy(new_ci, L->base_ci, L->base_ci_size);
- memset(new_ci + (L->base_ci_size / sizeof(CallInfo)), 0, (new_ci_size) - L->base_ci_size);
- luaM_free(L->base_ci);
- L->base_ci = new_ci;
- L->base_ci_size = new_ci_size;
- L->ci = L->base_ci + index_ci;
- L->end_ci = L->base_ci + size_ci * 2;
- }
- L->ci++;
- if (ttype(f) == LUA_T_CLOSURE) {
- L->ci->c = clvalue(f);
- f = &L->ci->c->consts[0]; /* Get the actual function */
- }
- else
- L->ci->c = NULL;
- L->ci->base = base;
- L->ci->nResults = nResults;
- if (ttype(f)==LUA_T_CPROTO) {
- L->ci->tf = NULL;
- L->ci->pc = NULL;
- }
- else {
- Byte *pc = tfvalue(f)->code;
- if (lua_callhook)
- luaD_callHook(base, tfvalue(f), 0);
- luaD_checkstack((*pc++)+EXTRA_STACK);
- if (*pc < ZEROVARARG)
- luaD_adjusttop(base+*(pc++));
- else { /* varargs */
- luaC_checkGC();
- adjust_varargs(base+(*pc++)-ZEROVARARG);
- }
- L->ci->tf = tfvalue(f);
- L->ci->pc = pc;
- }
+void luaD_precall(TObject *f, StkId base, int32 nResults) {
+ // Create a new CallInfo record
+ if (L->ci+1 == L->end_ci) {
+ int32 size_ci = L->end_ci - L->base_ci;
+ int32 index_ci = L->ci - L->base_ci;
+ int32 new_ci_size = size_ci * 2 * sizeof(CallInfo);
+ CallInfo *new_ci = (CallInfo *)luaM_malloc(new_ci_size);
+ memcpy(new_ci, L->base_ci, L->base_ci_size);
+ memset(new_ci + (L->base_ci_size / sizeof(CallInfo)), 0, (new_ci_size) - L->base_ci_size);
+ luaM_free(L->base_ci);
+ L->base_ci = new_ci;
+ L->base_ci_size = new_ci_size;
+ L->ci = L->base_ci + index_ci;
+ L->end_ci = L->base_ci + size_ci * 2;
+ }
+ L->ci++;
+ if (ttype(f) == LUA_T_CLOSURE) {
+ L->ci->c = clvalue(f);
+ f = &L->ci->c->consts[0]; // Get the actual function
+ } else {
+ L->ci->c = NULL;
+ }
+ L->ci->base = base;
+ L->ci->nResults = nResults;
+ if (ttype(f)==LUA_T_CPROTO) {
+ L->ci->tf = NULL;
+ L->ci->pc = NULL;
+ } else {
+ Byte *pc = tfvalue(f)->code;
+ if (lua_callhook)
+ luaD_callHook(base, tfvalue(f), 0);
+ luaD_checkstack((*pc++) + EXTRA_STACK);
+ if (*pc < ZEROVARARG) {
+ luaD_adjusttop(base + *(pc++));
+ } else { // varargs
+ luaC_checkGC();
+ adjust_varargs(base + (*pc++) - ZEROVARARG);
+ }
+ L->ci->tf = tfvalue(f);
+ L->ci->pc = pc;
+ }
}
/*
** Adjust the stack to the desired number of results
*/
-void luaD_postret (StkId firstResult) {
- int32 i;
- StkId base = L->ci->base;
- int32 nResults = L->ci->nResults;
- if (L->ci == L->base_ci)
- lua_error("call stack underflow");
- /* adjust the number of results */
- if (nResults != MULT_RET)
- luaD_adjusttop(firstResult+nResults);
- /* move results to base-1 (to erase parameters and function) */
- base--;
- nResults = L->stack.top - (L->stack.stack+firstResult); /* actual number of results */
- for (i=0; i<nResults; i++)
- *(L->stack.stack+base+i) = *(L->stack.stack+firstResult+i);
- L->stack.top -= firstResult-base;
- /* pop off the current CallInfo */
- L->ci--;
+void luaD_postret(StkId firstResult) {
+ int32 i;
+ StkId base = L->ci->base;
+ int32 nResults = L->ci->nResults;
+ if (L->ci == L->base_ci)
+ lua_error("call stack underflow");
+ // adjust the number of results
+ if (nResults != MULT_RET)
+ luaD_adjusttop(firstResult + nResults);
+ // move results to base - 1 (to erase parameters and function)
+ base--;
+ nResults = L->stack.top - (L->stack.stack + firstResult); // actual number of results
+ for (i = 0; i < nResults; i++)
+ *(L->stack.stack + base + i) = *(L->stack.stack + firstResult + i);
+ L->stack.top -= firstResult - base;
+ // pop off the current CallInfo
+ L->ci--;
}
/*
@@ -279,245 +248,204 @@
** When returns, the results are on the L->stack.stack, between [L->stack.stack+base-1,L->stack.top).
** The number of results is nResults, unless nResults=MULT_RET.
*/
-void luaD_call (StkId base, int32 nResults)
-{
- StkId firstResult;
- TObject *func = L->stack.stack+base-1;
- switch (ttype(func)) {
- case LUA_T_CPROTO:
- luaD_precall(func, base, nResults);
- ttype(func) = LUA_T_CMARK;
- firstResult = callC(fvalue(func), base);
- break;
- case LUA_T_PROTO:
- luaD_precall(func, base, nResults);
- ttype(func) = LUA_T_PMARK;
- firstResult = luaV_execute(L->ci);
- break;
- case LUA_T_CLOSURE: {
- Closure *c = clvalue(func);
- TObject *proto = &(c->consts[0]);
- luaD_precall(func, base, nResults);
- ttype(func) = LUA_T_CLMARK;
- firstResult = (ttype(proto) == LUA_T_CPROTO) ?
- callCclosure(c, fvalue(proto), base) :
- luaV_execute(L->ci);
- break;
- }
- default: { /* func is not a function */
- /* Check the tag method for invalid functions */
- TObject *im = luaT_getimbyObj(func, IM_FUNCTION);
- if (ttype(im) == LUA_T_NIL)
- lua_error("call expression not a function");
- luaD_callTM(im, (L->stack.top-L->stack.stack)-(base-1), nResults);
- return;
- }
- }
- luaD_postret(firstResult);
+void luaD_call(StkId base, int32 nResults) {
+ StkId firstResult;
+ TObject *func = L->stack.stack + base - 1;
+ switch (ttype(func)) {
+ case LUA_T_CPROTO:
+ luaD_precall(func, base, nResults);
+ ttype(func) = LUA_T_CMARK;
+ firstResult = callC(fvalue(func), base);
+ break;
+ case LUA_T_PROTO:
+ luaD_precall(func, base, nResults);
+ ttype(func) = LUA_T_PMARK;
+ firstResult = luaV_execute(L->ci);
+ break;
+ case LUA_T_CLOSURE:
+ {
+ Closure *c = clvalue(func);
+ TObject *proto = &(c->consts[0]);
+ luaD_precall(func, base, nResults);
+ ttype(func) = LUA_T_CLMARK;
+ firstResult = (ttype(proto) == LUA_T_CPROTO) ? callCclosure(c, fvalue(proto), base) : luaV_execute(L->ci);
+ break;
+ }
+ default:
+ { // func is not a function
+ // Check the tag method for invalid functions
+ TObject *im = luaT_getimbyObj(func, IM_FUNCTION);
+ if (ttype(im) == LUA_T_NIL)
+ lua_error("call expression not a function");
+ luaD_callTM(im, (L->stack.top - L->stack.stack) - (base - 1), nResults);
+ return;
+ }
+ }
+ luaD_postret(firstResult);
}
-
-static void travstack (struct Stack *S, int32 (*fn)(TObject *)) {
- StkId i;
- for (i = (S->top-1)-S->stack; i>=0; i--)
- fn(S->stack+i);
+static void travstack(struct Stack *S, int32 (*fn)(TObject *)) {
+ StkId i;
+ for (i = (S->top - 1) - S->stack; i >= 0; i--)
+ fn(S->stack + i);
}
/*
** Traverse all objects on L->stack.stack, and all other active stacks
*/
-void luaD_travstack (int32 (*fn)(TObject *))
-{
- struct lua_Task *t;
- travstack(&L->stack, fn);
- for (t = L->root_task; t != NULL; t = t->next)
- if (t != L->curr_task && t->Tstate != DONE)
- travstack(&t->stack, fn);
+void luaD_travstack(int32(*fn)(TObject *)) {
+ struct lua_Task *t;
+ travstack(&L->stack, fn);
+ for (t = L->root_task; t != NULL; t = t->next)
+ if (t != L->curr_task && t->Tstate != DONE)
+ travstack(&t->stack, fn);
}
-
-
-static void message (const char *s)
-{
- TObject im = L->errorim;
- if (ttype(&im) != LUA_T_NIL) {
- lua_pushstring(s);
- luaD_callTM(&im, 1, 0);
- }
+static void message(const char *s) {
+ TObject im = L->errorim;
+ if (ttype(&im) != LUA_T_NIL) {
+ lua_pushstring(s);
+ luaD_callTM(&im, 1, 0);
+ }
}
/*
** Reports an error, and jumps up to the available recover label
*/
-void lua_error (const char *s)
-{
- if (s) message(s);
- if (L->errorJmp)
- longjmp(*((jmp_buf *)L->errorJmp), 1);
- else {
- fprintf (stderr, "lua: exit(1). Unable to recover\n");
- exit(1);
- }
+void lua_error(const char *s) {
+ if (s)
+ message(s);
+ if (L->errorJmp) {
+ longjmp(*((jmp_buf *)L->errorJmp), 1);
+ } else {
+ fprintf(stderr, "lua: exit(1). Unable to recover\n");
+ exit(1);
+ }
}
/*
** Call the function at L->Cstack.base, and incorporate results on
** the Lua2C structure.
*/
-static void do_callinc (int32 nResults)
-{
- StkId base = L->Cstack.base;
- luaD_call(base+1, nResults);
- L->Cstack.lua2C = base; /* position of the luaM_new results */
- L->Cstack.num = (L->stack.top-L->stack.stack) - base; /* number of results */
- L->Cstack.base = base + L->Cstack.num; /* incorporate results on L->stack.stack */
+static void do_callinc(int32 nResults) {
+ StkId base = L->Cstack.base;
+ luaD_call(base + 1, nResults);
+ L->Cstack.lua2C = base; // position of the luaM_new results
+ L->Cstack.num = (L->stack.top - L->stack.stack) - base; // number of results
+ L->Cstack.base = base + L->Cstack.num; // incorporate results on L->stack.stack/
}
-
/*
** Execute a protected call. Assumes that function is at L->Cstack.base and
** parameters are on top of it. Leave nResults on the stack.
*/
-int32 luaD_protectedrun (int32 nResults)
-{
- jmp_buf myErrorJmp;
- int32 status;
- struct C_Lua_Stack oldCLS = L->Cstack;
- jmp_buf *oldErr = L->errorJmp;
- int32 ci_len = L->ci - L->base_ci;
- L->errorJmp = &myErrorJmp;
- if (setjmp(myErrorJmp) == 0) {
- do_callinc(nResults);
- status = 0;
- }
- else { /* an error occurred: restore L->Cstack and L->stack.top */
- L->Cstack = oldCLS;
- L->stack.top = L->stack.stack+L->Cstack.base;
- L->ci = L->base_ci + ci_len;
- status = 1;
- }
- L->errorJmp = oldErr;
- return status;
+int32 luaD_protectedrun(int32 nResults) {
+ jmp_buf myErrorJmp;
+ int32 status;
+ struct C_Lua_Stack oldCLS = L->Cstack;
+ jmp_buf *oldErr = L->errorJmp;
+ int32 ci_len = L->ci - L->base_ci;
+ L->errorJmp = &myErrorJmp;
+ if (setjmp(myErrorJmp) == 0) {
+ do_callinc(nResults);
+ status = 0;
+ } else { // an error occurred: restore L->Cstack and L->stack.top
+ L->Cstack = oldCLS;
+ L->stack.top = L->stack.stack + L->Cstack.base;
+ L->ci = L->base_ci + ci_len;
+ status = 1;
+ }
+ L->errorJmp = oldErr;
+ return status;
}
-
/*
** returns 0 = chunk loaded; 1 = error; 2 = no more chunks to load
*/
-static int32 protectedparser (ZIO *z, int32 bin)
-{
- volatile int32 status;
- TProtoFunc *volatile tf;
- jmp_buf myErrorJmp;
- jmp_buf *volatile oldErr = L->errorJmp;
- L->errorJmp = &myErrorJmp;
- if (setjmp(myErrorJmp) == 0) {
- tf = bin ? luaU_undump1(z) : luaY_parser(z);
- status = 0;
- }
- else {
- tf = NULL;
- status = 1;
- }
- L->errorJmp = oldErr;
- if (status) return 1; /* error code */
- if (tf == NULL) return 2; /* 'natural' end */
- luaD_adjusttop(L->Cstack.base+1); /* one slot for the pseudo-function */
- L->stack.stack[L->Cstack.base].ttype = LUA_T_PROTO;
- L->stack.stack[L->Cstack.base].value.tf = tf;
- luaV_closure(0);
- return 0;
+static int32 protectedparser(ZIO *z, int32 bin) {
+ volatile int32 status;
+ TProtoFunc *volatile tf;
+ jmp_buf myErrorJmp;
+ jmp_buf *volatile oldErr = L->errorJmp;
+ L->errorJmp = &myErrorJmp;
+ if (setjmp(myErrorJmp) == 0) {
+ tf = bin ? luaU_undump1(z) : luaY_parser(z);
+ status = 0;
+ } else {
+ tf = NULL;
+ status = 1;
+ }
+ L->errorJmp = oldErr;
+ if (status)
+ return 1; // error code
+ if (tf == NULL)
+ return 2; // 'natural' end
+ luaD_adjusttop(L->Cstack.base + 1); // one slot for the pseudo-function
+ L->stack.stack[L->Cstack.base].ttype = LUA_T_PROTO;
+ L->stack.stack[L->Cstack.base].value.tf = tf;
+ luaV_closure(0);
+ return 0;
}
-
-static int32 do_main (ZIO *z, int32 bin)
-{
- int32 status;
- do {
- int32 old_blocks = (luaC_checkGC(), L->nblocks);
- status = protectedparser(z, bin);
- if (status == 1) return 1; /* error */
- else if (status == 2) return 0; /* 'natural' end */
- else {
- int32 newelems2 = 2*(L->nblocks-old_blocks);
- L->GCthreshold += newelems2;
- status = luaD_protectedrun(MULT_RET);
- L->GCthreshold -= newelems2;
- }
- } while (bin && status == 0);
- return status;
+static int32 do_main(ZIO *z, int32 bin) {
+ int32 status;
+ do {
+ int32 old_blocks = (luaC_checkGC(), L->nblocks);
+ status = protectedparser(z, bin);
+ if (status == 1)
+ return 1; // error
+ else if (status == 2)
+ return 0; // 'natural' end
+ else {
+ int32 newelems2 = 2 * (L->nblocks - old_blocks);
+ L->GCthreshold += newelems2;
+ status = luaD_protectedrun(MULT_RET);
+ L->GCthreshold -= newelems2;
+ }
+ } while (bin && status == 0);
+ return status;
}
-
-void luaD_gcIM (TObject *o)
-{
- TObject *im = luaT_getimbyObj(o, IM_GC);
- if (ttype(im) != LUA_T_NIL) {
- *L->stack.top = *o;
- incr_top;
- luaD_callTM(im, 1, 0);
- }
+void luaD_gcIM(TObject *o) {
+ TObject *im = luaT_getimbyObj(o, IM_GC);
+ if (ttype(im) != LUA_T_NIL) {
+ *L->stack.top = *o;
+ incr_top;
+ luaD_callTM(im, 1, 0);
+ }
}
-
-int32 lua_dofile (const char *filename)
-{
- ZIO z;
- int32 status;
- int32 c;
- int32 bin;
- FILE *f = (filename == NULL) ? stdin : fopen(filename, "r");
- if (f == NULL)
- return 2;
- if (filename == NULL)
- filename = "(stdin)";
- c = fgetc(f);
- ungetc(c, f);
- bin = (c == ID_CHUNK);
- if (bin)
- f = freopen(filename, "rb", f); /* set binary mode */
- luaZ_Fopen(&z, f, filename);
- status = do_main(&z, bin);
- if (f != stdin)
- fclose(f);
- return status;
-}
-
-
-#define SIZE_PREF 20 /* size of string prefix to appear in error messages */
+#define SIZE_PREF 20 // size of string prefix to appear in error messages
#define SSIZE_PREF "20"
-
static void build_name (const char *str, char *name) {
- if (str == NULL || *str == ID_CHUNK)
- strcpy(name, "(buffer)");
- else {
- char *temp;
- sprintf(name, "(dostring) >> \"%." SSIZE_PREF "s\"", str);
- temp = strchr(name, '\n');
- if (temp) { /* end string after first line */
- *temp = '"';
- *(temp+1) = 0;
- }
- }
+ if (str == NULL || *str == ID_CHUNK)
+ strcpy(name, "(buffer)");
+ else {
+ char *temp;
+ sprintf(name, "(dostring) >> \"%." SSIZE_PREF "s\"", str);
+ temp = strchr(name, '\n');
+ if (temp) { // end string after first line
+ *temp = '"';
+ *(temp + 1) = 0;
+ }
+ }
}
-
-int32 lua_dostring (const char *str) {
- return lua_dobuffer(str, strlen(str), NULL);
+int32 lua_dostring(const char *str) {
+ return lua_dobuffer(str, strlen(str), NULL);
}
+int32 lua_dobuffer(const char *buff, int32 size, const char *name) {
+ char newname[SIZE_PREF + 25];
+ ZIO z;
+ int32 status;
-int32 lua_dobuffer (const char *buff, int32 size, const char *name) {
- char newname[SIZE_PREF+25];
- ZIO z;
- int32 status;
- if (name==NULL) {
- build_name(buff, newname);
- name = newname;
- }
- luaZ_mopen(&z, buff, size, name);
- status = do_main(&z, buff[0]==ID_CHUNK);
- return status;
+ if (!name) {
+ build_name(buff, newname);
+ name = newname;
+ }
+ luaZ_mopen(&z, buff, size, name);
+ status = do_main(&z, buff[0] == ID_CHUNK);
+ return status;
}
-
Modified: residual/trunk/engine/lua/ldo.h
===================================================================
--- residual/trunk/engine/lua/ldo.h 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/ldo.h 2008-07-28 14:51:57 UTC (rev 33378)
@@ -8,42 +8,38 @@
#define ldo_h
-#include "lobject.h"
-#include "lstate.h"
+#include "engine/lua/lobject.h"
+#include "engine/lua/lstate.h"
#define MULT_RET 255
-
/*
** macro to increment stack top.
** There must be always an empty slot at the L->stack.top
*/
-#define incr_top { if (L->stack.top >= L->stack.last) luaD_checkstack(1); \
- L->stack.top++; }
+#define incr_top { if (L->stack.top >= L->stack.last) luaD_checkstack(1); L->stack.top++; }
+// macros to convert from lua_Object to (TObject *) and back
-/* macros to convert from lua_Object to (TObject *) and back */
+#define Address(lo) ((lo) + L->stack.stack - 1)
+#define Ref(st) ((st) - L->stack.stack + 1)
-#define Address(lo) ((lo)+L->stack.stack-1)
-#define Ref(st) ((st)-L->stack.stack+1)
+void luaD_init();
+void luaD_initthr();
+void luaD_adjusttop(StkId newtop);
+void luaD_openstack(int32 nelems);
+void luaD_lineHook(int32 line);
+void luaD_callHook(StkId base, TProtoFunc *tf, int32 isreturn);
+void luaD_precall(TObject *f, StkId base, int32 nResults);
+void luaD_postret(StkId firstResult);
+void luaD_call(StkId base, int32 nResults);
+void luaD_callTM(TObject *f, int32 nParams, int32 nResults);
+int32 luaD_protectedrun(int32 nResults);
+void luaD_gcIM(TObject *o);
+void luaD_travstack(int32 (*fn)(TObject *));
+void luaD_checkstack(int32 n);
-void luaD_init (void);
-void luaD_initthr (void);
-void luaD_adjusttop (StkId newtop);
-void luaD_openstack (int32 nelems);
-void luaD_lineHook (int32 line);
-void luaD_callHook (StkId base, TProtoFunc *tf, int32 isreturn);
-void luaD_precall (TObject *f, StkId base, int32 nResults);
-void luaD_postret (StkId firstResult);
-void luaD_call (StkId base, int32 nResults);
-void luaD_callTM (TObject *f, int32 nParams, int32 nResults);
-int32 luaD_protectedrun (int32 nResults);
-void luaD_gcIM (TObject *o);
-void luaD_travstack (int32 (*fn)(TObject *));
-void luaD_checkstack (int32 n);
-
-
#endif
Modified: residual/trunk/engine/lua/lua.h
===================================================================
--- residual/trunk/engine/lua/lua.h 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/lua.h 2008-07-28 14:51:57 UTC (rev 33378)
@@ -64,7 +64,6 @@
void lua_settag (int32 tag); /* In: object */
void lua_error (const char *s);
-int32 lua_dofile (const char *filename); /* Out: returns */
int32 lua_dostring (const char *string); /* Out: returns */
int32 lua_dobuffer (const char *buff, int32 size, const char *name);
/* Out: returns */
Modified: residual/trunk/engine/lua/lundump.cpp
===================================================================
--- residual/trunk/engine/lua/lundump.cpp 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/lundump.cpp 2008-07-28 14:51:57 UTC (rev 33378)
@@ -161,6 +161,7 @@
LoadConstants(tf, Z);
LoadLocals(tf, Z);
LoadSubfunctions(tf, Z);
+
return tf;
}
@@ -176,7 +177,8 @@
static void LoadHeader(ZIO *Z) {
int32 version, id, sizeofR;
#if 0
- real f = (real)-TEST_NUMBER, tf = (real)TEST_NUMBER;
+ real f = (real)-TEST_NUMBER;
+ real tf = (real)TEST_NUMBER;
#endif
LoadSignature(Z);
version = ezgetc(Z);
Modified: residual/trunk/engine/lua/lzio.cpp
===================================================================
--- residual/trunk/engine/lua/lzio.cpp 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/lzio.cpp 2008-07-28 14:51:57 UTC (rev 33378)
@@ -5,76 +5,35 @@
*/
-#include "lzio.h"
+#include "engine/lua/lzio.h"
+#include "common/file.h"
-
-/* ----------------------------------------------------- memory buffers --- */
-
-static int32 zmfilbuf (ZIO* /*z*/)
-{
- return EOZ;
+int32 zgeteoz(ZIO *) {
+ return EOZ;
}
-ZIO* zmopen (ZIO* z, const char* b, int32 size, const char *name)
-{
- if (b==NULL) return NULL;
- z->n=size;
- z->p= (const byte *)b;
- z->filbuf=zmfilbuf;
- z->u=NULL;
- z->name=name;
- return z;
+ZIO *zopen(ZIO *z, const char *b, int32 size, const char *name) {
+ if (!b)
+ return NULL;
+ z->n = size;
+ z->p = (const byte *)b;
+ z->name = name;
+ return z;
}
-/* ------------------------------------------------------------ strings --- */
-
-ZIO* zsopen (ZIO* z, const char* s, const char *name)
-{
- if (s==NULL) return NULL;
- return zmopen(z,s,strlen(s),name);
+int32 zread (ZIO *z, void *b, int32 n) {
+ while (n) {
+ int32 m;
+ if (z->n == 0) {
+ return n;
+ }
+ m = (n <= z->n) ? n : z->n;
+ memcpy(b, z->p, m);
+ z->n -= m;
+ z->p += m;
+ b = (char *)b + m;
+ n -= m;
+ }
+ return 0;
}
-
-/* -------------------------------------------------------------- FILEs --- */
-
-static int32 zffilbuf (ZIO* z)
-{
- int32 n=fread(z->buffer,1,ZBSIZE,(FILE *)z->u);
- if (n==0) return EOZ;
- z->n=n-1;
- z->p=z->buffer;
- return *(z->p++);
-}
-
-
-ZIO* zFopen (ZIO* z, FILE* f, const char *name)
-{
- if (f==NULL) return NULL;
- z->n=0;
- z->p=z->buffer;
- z->filbuf=zffilbuf;
- z->u=f;
- z->name=name;
- return z;
-}
-
-
-/* --------------------------------------------------------------- read --- */
-int32 zread (ZIO *z, void *b, int32 n)
-{
- while (n) {
- int32 m;
- if (z->n == 0) {
- if (z->filbuf(z) == EOZ)
- return n; /* retorna quantos faltaram ler */
- zungetc(z); /* poe o resultado de filbuf no buffer */
- }
- m = (n <= z->n) ? n : z->n; /* minimo de n e z->n */
- memcpy(b, z->p, m);
- z->n -= m;
- z->p += m;
- b = (char *)b + m;
- n -= m;
- }
- return 0;
-}
Modified: residual/trunk/engine/lua/lzio.h
===================================================================
--- residual/trunk/engine/lua/lzio.h 2008-07-28 14:23:49 UTC (rev 33377)
+++ residual/trunk/engine/lua/lzio.h 2008-07-28 14:51:57 UTC (rev 33378)
@@ -10,39 +10,35 @@
#include <common/sys.h>
+namespace Common {
+ class File;
+}
+// For Lua only
+#define zopen luaZ_mopen
-/* For Lua only */
-#define zFopen luaZ_Fopen
-#define zsopen luaZ_sopen
-#define zmopen luaZ_mopen
+#define EOZ (-1) // end of stream
-#define EOZ (-1) /* end of stream */
-
typedef struct zio ZIO;
-ZIO* zFopen (ZIO* z, FILE* f, const char *name); /* open FILEs */
-ZIO* zsopen (ZIO* z, const char* s, const char *name); /* string */
-ZIO* zmopen (ZIO* z, const char* b, int32 size, const char *name); /* memory */
+ZIO *zopen(ZIO *z, const char *b, int32 size, const char *name);
+int32 zread(ZIO *z, void *b, int32 n); // read next n bytes
+int32 zgeteoz(ZIO *);
-int32 zread (ZIO* z, void* b, int32 n); /* read next n bytes */
-
-#define zgetc(z) (--(z)->n>=0 ? ((int32)*(z)->p++): (z)->filbuf(z))
+#define zgetc(z) (--(z)->n >= 0 ? ((int32)*(z)->p++): zgeteoz(z))
#define zungetc(z) (++(z)->n,--(z)->p)
#define zname(z) ((z)->name)
-/* --------- Private Part ------------------ */
+// --------- Private Part ------------------
-#define ZBSIZE 256 /* buffer size */
+#define ZBSIZE 256 // buffer size
struct zio {
- int32 n; /* bytes still unread */
- const byte* p; /* current position in buffer */
- int32 (*filbuf)(ZIO* z);
- void* u; /* additional data */
- const char *name;
- byte buffer[ZBSIZE]; /* buffer */
+ int32 n; // bytes still unread
+ const byte *p; // current position in buffer
+ const char *name;
+ byte buffer[ZBSIZE]; // buffer
};
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