static int addk (FuncState *fs, TValue *k, TValue *v) {
lua_State *L = fs->L;
TValue *idx = luaH_set(L, fs->h, k);
Proto *f = fs->f;
int oldsize = f->sizek;
if (ttisnumber(idx)) {
lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
return cast_int(nvalue(idx));
}
else { /* constant not found; create a new entry */
setnvalue(idx, cast_num(fs->nk));
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.constants");
#endif /* LUA_MEMORY_STATS */
luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
MAXARG_Bx, "constant table overflow");
#if LUA_MEMORY_STATS
luaM_setname(L, 0);
#endif /* LUA_MEMORY_STATS */
#if LUA_REFCOUNT
while (oldsize < f->sizek) setnilvalue2n(L, &f->k[oldsize++]);
#else
while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
#endif /* LUA_REFCOUNT */
setobj(L, &f->k[fs->nk], v);
luaC_barrier(L, f, v);
return fs->nk++;
}
}
/* ------------------------------------------------------------------------ */
void luaZ_resizebuffer(lua_State *L, Mbuffer *buff, size_t size)
{
luaM_setname(L, "lua.buffer");
luaM_reallocvector(L, buff->buffer, buff->buffsize, size, char);
luaM_setname(L, 0);
buff->buffsize = size;
}
static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
int i;
Proto *f = fs->f;
int oldsize = f->sizeupvalues;
for (i=0; i<f->nups; i++) {
if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
lua_assert(f->upvalues[i] == name);
return i;
}
}
/* new one */
luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
#if LUA_MEMORY_STATS
luaM_setname(fs->L, "lua.parser.upvalues");
#endif /* LUA_MEMORY_STATS */
luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
TString *, MAX_INT, "");
#if LUA_MEMORY_STATS
luaM_setname(fs->L, 0);
#endif /* LUA_MEMORY_STATS */
while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
f->upvalues[f->nups] = name;
#if LUA_REFCOUNT
luarc_addrefstring(name);
#endif /* LUA_REFCOUNT */
luaC_objbarrier(fs->L, f, name);
lua_assert(v->k == VLOCAL || v->k == VUPVAL);
fs->upvalues[f->nups].k = cast_byte(v->k);
fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
return f->nups++;
}
static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
FuncState *fs = ls->fs;
Proto *f = fs->f;
int oldsize = f->sizep;
int i;
#if LUA_MEMORY_STATS
luaM_setname(ls->L, "lua.parser.closures");
#endif /* LUA_MEMORY_STATS */
luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
MAXARG_Bx, "constant table overflow");
#if LUA_MEMORY_STATS
luaM_setname(ls->L, 0);
#endif /* LUA_MEMORY_STATS */
while (oldsize < f->sizep) f->p[oldsize++] = NULL;
f->p[fs->np++] = func->f;
#if LUA_REFCOUNT
/* already got a reference */
/* luarc_addrefproto(func->f); */
#endif /* LUA_REFCOUNT */
luaC_objbarrier(ls->L, f, func->f);
init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
for (i=0; i<func->f->nups; i++) {
OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
}
}
static void stack_init (lua_State *L1, lua_State *L) {
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.callinfo");
#endif /* LUA_MEMORY_STATS */
/* initialize CallInfo array */
L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
L1->ci = L1->base_ci;
L1->size_ci = BASIC_CI_SIZE;
L1->end_ci = L1->base_ci + L1->size_ci - 1;
/* initialize stack array */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.stack");
#endif /* LUA_MEMORY_STATS */
L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
L1->top = L1->stack;
L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
#if LUA_REFCOUNT
luarc_newarray(L1->stack, L1->stack + L1->stacksize);
#endif /* LUA_REFCOUNT */
/* initialize first ci */
L1->ci->func = L1->top;
#if LUA_REFCOUNT
setnilvalue2n(L1, L1->top++); /* `function' entry for this `ci' */
#else
setnilvalue(L1->top++); /* `function' entry for this `ci' */
#endif /* LUA_REFCOUNT */
L1->base = L1->ci->base = L1->top;
L1->ci->top = L1->top + LUA_MINSTACK;
#if LUA_MEMORY_STATS
luaM_setname(L, 0);
#endif /* LUA_MEMORY_STATS */
}
static int f_luaopen (lua_State *L, void *ud) {
#else
static void f_luaopen (lua_State *L, void *ud) {
#endif /* LUA_EXT_RESUMABLEVM */
global_State *g = G(L);
UNUSED(ud);
stack_init(L, L); /* init stack */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.globals");
#endif /* LUA_MEMORY_STATS */
sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.registry");
#endif /* LUA_MEMORY_STATS */
sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */
#if LUA_FASTREF_SUPPORT
{
TValue n;
sethvalue(L, &G(L)->l_refs, luaH_new(L, 0, 2)); /* refs */
setnvalue(&n, 0);
setobj2t(L, luaH_setnum(L, hvalue(&G(L)->l_refs), LUA_RIDX_FASTREF_FREELIST), &n);
setnilvalue(&g->fastrefNilValue);
}
#endif /* LUA_FASTREF_SUPPORT */
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
luaT_init(L);
luaX_init(L);
luaS_fix(luaS_newliteral(L, MEMERRMSG));
g->GCthreshold = 4*g->totalbytes;
#if LUA_EXT_RESUMABLEVM
return 0;
#endif /* LUA_EXT_RESUMABLEVM */
}
Proto *luaF_newproto (lua_State *L) {
Proto *f;
luaM_setname(L, "Lua_proto");
f = luaM_new(L, Proto);
#if LUA_REFCOUNT
f->ref = 0;
#endif LUA_REFCOUNT
luaC_link(L, valtogco(f), LUA_TPROTO);
f->k = NULL;
f->sizek = 0;
f->p = NULL;
f->sizep = 0;
f->code = NULL;
f->sizecode = 0;
f->sizelineinfo = 0;
f->sizeupvalues = 0;
f->nups = 0;
f->upvalues = NULL;
f->numparams = 0;
f->is_vararg = 0;
f->maxstacksize = 0;
f->lineinfo = NULL;
f->sizelocvars = 0;
f->locvars = NULL;
f->lineDefined = 0;
f->source = NULL;
return f;
}
static void LoadCode (LoadState* S, Proto* f)
{
int size=LoadInt(S);
luaM_setname(S->L, "Lua_code");
f->code=luaM_newvector(S->L,size,Instruction);
f->sizecode=size;
LoadVector(S,f->code,size,sizeof(*f->code));
}
static void LoadLines (LoadState* S, Proto* f)
{
int size=LoadInt(S);
luaM_setname(S->L, "Lua_lines");
f->lineinfo=luaM_newvector(S->L,size,int);
f->sizelineinfo=size;
LoadVector(S,f->lineinfo,size,sizeof(*f->lineinfo));
}
/*
** open parts that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
global_State *g = G(L);
UNUSED(ud);
stack_init(L, L); /* init stack */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.globals");
#endif /* LUA_MEMORY_STATS */
sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.registry");
#endif /* LUA_MEMORY_STATS */
sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
luaT_init(L);
luaX_init(L);
luaS_fix(luaS_newliteral(L, MEMERRMSG));
g->GCthreshold = 4*g->totalbytes;
}
static void setarrayvector (lua_State *L, Table *t, int size) {
int i;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.arrayvector");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
#if LUA_REFCOUNT
for (i=t->sizearray; i<size; i++)
setnilvalue2n(L, &t->array[i]);
#else
for (i=t->sizearray; i<size; i++)
setnilvalue(&t->array[i]);
#endif /* LUA_REFCOUNT */
t->sizearray = size;
#if LUA_MEMORY_STATS
luaM_setname(L, 0);
#endif /* LUA_MEMORY_STATS */
}
static int registerlocalvar (LexState *ls, TString *varname) {
FuncState *fs = ls->fs;
Proto *f = fs->f;
int oldsize = f->sizelocvars;
#if LUA_MEMORY_STATS
luaM_setname(ls->L, "lua.parser.locals");
#endif /* LUA_MEMORY_STATS */
luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
LocVar, SHRT_MAX, "too many local variables");
#if LUA_MEMORY_STATS
luaM_setname(ls->L, 0);
#endif /* LUA_MEMORY_STATS */
while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
f->locvars[fs->nlocvars].varname = varname;
luaC_objbarrier(ls->L, f, varname);
#if LUA_REFCOUNT
luarc_addrefstring(varname);
#endif /* LUA_REFCOUNT */
return fs->nlocvars++;
}
Closure *luaF_newCclosure (lua_State *L, int nelems) {
Closure *c;
luaM_setname(L, "Lua_closure");
c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
#if LUA_REFCOUNT
c->c.ref = 0;
#endif LUA_REFCOUNT
luaC_link(L, valtogco(c), LUA_TFUNCTION);
c->c.isC = 1;
c->c.nupvalues = cast(lu_byte, nelems);
return c;
}
static void LoadUpvalues (LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
if (n!=0 && n!=f->nups)
luaG_runerror(S->L,"bad nupvalues in %s: read %d; expected %d",
S->name,n,f->nups);
luaM_setname(S->L, "Lua_upvalues");
f->upvalues=luaM_newvector(S->L,n,TString*);
f->sizeupvalues=n;
for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
}
static void close_func (LexState *ls) {
lua_State *L = ls->L;
FuncState *fs = ls->fs;
Proto *f = fs->f;
removevars(ls, 0);
luaK_codeABC(fs, OP_RETURN, 0, 1, 0); /* final return */
luaM_setname(L, "Lua_parser_code");
luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
f->sizecode = fs->pc;
luaM_setname(L, "Lua_parser_lineinfo");
luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
f->sizelineinfo = fs->pc;
luaM_setname(L, "Lua_parser_constants");
luaM_reallocvector(L, f->k, f->sizek, fs->nk, TObject);
f->sizek = fs->nk;
luaM_setname(L, "Lua_parser_proto");
luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
f->sizep = fs->np;
luaM_setname(L, "Lua_parser_locals");
luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
f->sizelocvars = fs->nlocvars;
luaM_setname(L, "Lua_parser_upvalues");
luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
f->sizeupvalues = f->nups;
lua_assert(luaG_checkcode(f));
lua_assert(fs->bl == NULL);
ls->fs = fs->prev;
#if LUA_REFCOUNT
__ReleaseDirect(L, (GCObject*)fs->h);
#endif LUA_REFCOUNT
}
static void stack_init (lua_State *L1, lua_State *L) {
#if LUA_REFCOUNT
StkId i;
#endif LUA_REFCOUNT
luaM_setname(L, "Lua_Stack");
L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TObject);
L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
L1->top = L1->stack;
L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
#if LUA_REFCOUNT
for (i = L1->stack; i != L1->stack_last; ++i)
setnilvalue2n(i);
#endif LUA_REFCOUNT
luaM_setname(L, "Lua_CallInfo");
L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
L1->ci = L1->base_ci;
L1->ci->state = CI_C; /* not a Lua function */
setnilvalue2n(L1->top++); /* `function' entry for this `ci' */
L1->base = L1->ci->base = L1->top;
L1->ci->top = L1->top + LUA_MINSTACK;
L1->size_ci = BASIC_CI_SIZE;
L1->end_ci = L1->base_ci + L1->size_ci;
}
static void close_func (LexState *ls) {
lua_State *L = ls->L;
FuncState *fs = ls->fs;
Proto *f = fs->f;
removevars(ls, 0);
luaK_ret(fs, 0, 0); /* final return */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.code");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
f->sizecode = fs->pc;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.lineinfo");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
f->sizelineinfo = fs->pc;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.constants");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
f->sizek = fs->nk;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.proto");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
f->sizep = fs->np;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.locals");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
f->sizelocvars = fs->nlocvars;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.parser.upvalues");
#endif /* LUA_MEMORY_STATS */
luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
#if LUA_MEMORY_STATS
luaM_setname(L, 0);
#endif /* LUA_MEMORY_STATS */
f->sizeupvalues = f->nups;
lua_assert(luaG_checkcode(f));
lua_assert(fs->bl == NULL);
ls->fs = fs->prev;
L->top -= 2; /* remove table and prototype from the stack */
/* last token read was anchored in defunct function; must reanchor it */
if (fs) anchor_token(ls);
#if LUA_REFCOUNT
setnilvalue(L->top + 1);
setnilvalue(L->top);
luarc_releasetable(L, fs->h);
#endif /* LUA_REFCOUNT */
}
Closure *luaF_newLclosure (lua_State *L, int nelems, TObject *e) {
Closure *c;
luaM_setname(L, "Lua_closure");
c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
#if LUA_REFCOUNT
c->l.ref = 0;
#endif LUA_REFCOUNT
luaC_link(L, valtogco(c), LUA_TFUNCTION);
c->l.isC = 0;
c->l.g = *e;
#if LUA_REFCOUNT
__AddRef(&c->l.g);
#endif LUA_REFCOUNT
c->l.nupvalues = cast(lu_byte, nelems);
return c;
}
lua_State *luaE_newthread (lua_State *L) {
lua_State *L1;
#if LUA_MEMORY_STATS
luaM_setname(L, "lua_State");
#endif /* LUA_MEMORY_STATS */
L1 = tostate(luaM_malloc(L, state_size(lua_State)));
luaC_link(L, obj2gco(L1), LUA_TTHREAD);
preinit_state(L1, G(L));
stack_init(L1, L); /* init stack */
setobj2n(L, gt(L1), gt(L)); /* share table of globals */
L1->hookmask = L->hookmask;
L1->basehookcount = L->basehookcount;
L1->hook = L->hook;
resethookcount(L1);
lua_assert(iswhite(obj2gco(L1)));
return L1;
}
static void LoadConstants (LoadState* S, Proto* f)
{
lua_State *L = S->L;
int i,n;
(void)L;
n=LoadInt(S);
luaM_setname(S->L, "Lua_constants");
f->k=luaM_newvector(S->L,n,TObject);
f->sizek=n;
for (i=0; i<n; i++)
{
TObject* o=&f->k[i];
int t=LoadByte(S);
switch (t)
{
case LUA_TNUMBER:
setnvalue2n(o,LoadNumber(S));
break;
case LUA_TSTRING:
setsvalue2n(o,LoadString(S));
break;
case LUA_TWSTRING:
setwsvalue2n(o,LoadWString(S));
break;
case LUA_TNIL:
setnilvalue2n(o);
break;
default:
luaG_runerror(S->L,"bad constant type (%d) in %s",t,S->name);
break;
}
}
n=LoadInt(S);
f->p=luaM_newvector(S->L,n,Proto*);
f->sizep=n;
for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
}
/*
** open parts that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
int i;
global_State globalState;
lua_State luaState;
global_State *g;
#ifdef _DEBUG
luaState.allocName = "Lua_global_State";
#endif _DEBUG
luaState.l_G = &globalState;
globalState.reallocFunc = luaHelper_Realloc;
globalState.freeFunc = luaHelper_Free;
globalState.memData = luaHelper_memData;
globalState.nblocks = sizeof(lua_State) + sizeof(global_State); // Bogus.
/* create a new global state */
g = luaM_new(&luaState, global_State);
UNUSED(ud);
if (g == NULL) luaD_throw(L, LUA_ERRMEM);
L->l_G = g;
g->mainthread = L;
g->GCthreshold = 0; /* mark it as unfinished state */
g->strt.size = 0;
g->strt.nuse = 0;
g->strt.hash = NULL;
setnilvalue2n(defaultmeta(L));
setnilvalue2n(registry(L));
luaZ_initbuffer(L, &g->buff);
g->panic = default_panic;
#if !LUA_REFCOUNT
g->rootgc = NULL;
g->rootudata = NULL;
g->tmudata = NULL;
#else LUA_REFCOUNT
g->rootgc_head.next = (GCObject*)&g->rootgc_tail;
g->rootgc_head.prev = NULL;
g->rootgc_tail.next = NULL;
g->rootgc_tail.prev = (GCObject*)&g->rootgc_head;
g->rootgc_head.tt = LUA_TNIL;
g->rootgc_head.marked = 0;
g->rootgc_head.ref = 0;
g->rootgc_tail.tt = LUA_TNIL;
g->rootgc_tail.marked = 0;
g->rootgc_tail.ref = 0;
g->rootudata_head.next = (GCObject*)&g->rootudata_tail;
g->rootudata_head.prev = NULL;
g->rootudata_tail.next = NULL;
g->rootudata_tail.prev = (GCObject*)&g->rootudata_head;
g->rootudata_head.tt = LUA_TNIL;
g->rootudata_head.marked = 0;
g->rootudata_head.ref = 0;
g->rootudata_tail.tt = LUA_TNIL;
g->rootudata_tail.marked = 0;
g->rootudata_tail.ref = 0;
g->tmudata_head.next = (GCObject*)&g->tmudata_tail;
g->tmudata_head.prev = NULL;
g->tmudata_tail.next = NULL;
g->tmudata_tail.prev = (GCObject*)&g->tmudata_head;
g->tmudata_head.tt = LUA_TNIL;
g->tmudata_head.marked = 0;
g->tmudata_head.ref = 0;
g->tmudata_tail.tt = LUA_TNIL;
g->tmudata_tail.marked = 0;
g->tmudata_tail.ref = 0;
#endif LUA_REFCOUNT
setnilvalue2n(gkey(g->dummynode));
setnilvalue2n(gval(g->dummynode));
g->dummynode->next = NULL;
g->nblocks = sizeof(lua_State) + sizeof(global_State);
g->reallocFunc = luaHelper_Realloc;
g->freeFunc = luaHelper_Free;
g->memData = luaHelper_memData;
g->fatalErrorFunc = defaultFatalErrorFunc;
#ifdef LUA_MTSUPPORT
g->lockData = NULL;
g->lockFunc = NULL;
g->unlockFunc = NULL;
#endif LUA_MTSUPPORT
g->userGCFunction = NULL;
g->globalUserData = NULL;
stack_init(L, L); /* init stack */
for (i = 0; i < LUA_NTYPES; i++)
{
defaultmetatypes(L, i)->value.gc = NULL;
}
/* create default meta table with a dummy table, and then close the loop */
defaultmeta(L)->tt = LUA_TNUMBER;
defaultmeta(L)->value.gc = NULL;
sethvalue2n(defaultmeta(L), luaH_new(L, 0, 0));
__AddRefDirect(hvalue(defaultmeta(L)));
hvalue(defaultmeta(L))->metatable = hvalue(defaultmeta(L));
__AddRefDirect(hvalue(defaultmeta(L))->metatable);
/* build meta tables */
for (i = 0; i < LUA_NTYPES; i++)
{
luaM_setname(L, "Lua_defaultMetaTypes");
sethvalue2n(defaultmetatypes(L, i), luaH_new(L, 0, 0));
hvalue(defaultmetatypes(L, i))->metatable = hvalue(defaultmeta(L));
}
luaM_setname(L, "Lua_Globals");
sethvalue(gt(L), luaH_new(L, 0, 4)); /* table of globals */
__AddRefDirect(hvalue(gt(L)));
luaM_setname(L, "Lua_Registry");
sethvalue(registry(L), luaH_new(L, 4, 4)); /* registry */
__AddRef(registry(L));
g->minimumstrings = lua_minimumnumstrings;
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
luaT_init(L);
luaX_init(L);
luaS_fix(luaS_newliteral(L, MEMERRMSG));
g->GCthreshold = 4*G(L)->nblocks;
luaZ_openspace(L, &g->buff, lua_minimumauxspace);
}
