static void LoadDebug(LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
f->lineinfo=luaM_newvector(S->L,n,int);
f->sizelineinfo=n;
LoadVector(S,f->lineinfo,n,sizeof(int));
n=LoadInt(S);
f->locvars=luaM_newvector(S->L,n,LocVar);
f->sizelocvars=n;
for (i=0; i<n; i++) f->locvars[i].varname=NULL;
for (i=0; i<n; i++)
{
f->locvars[i].varname=LoadString(S);
#if LUA_REFCOUNT
luarc_addrefstring(f->locvars[i].varname);
#endif /* LUA_REFCOUNT */
f->locvars[i].startpc=LoadInt(S);
f->locvars[i].endpc=LoadInt(S);
}
n=LoadInt(S);
f->upvalues=luaM_newvector(S->L,n,TString*);
f->sizeupvalues=n;
for (i=0; i<n; i++) f->upvalues[i]=NULL;
#if LUA_REFCOUNT
for (i=0; i<n; i++) {
f->upvalues[i]=LoadString(S);
luarc_addrefstring(f->upvalues[i]);
}
#else
for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
#endif /* LUA_REFCOUNT */
}
static void open_func (LexState *ls, FuncState *fs) {
lua_State *L = ls->L;
Proto *f = luaF_newproto(L);
fs->f = f;
fs->prev = ls->fs; /* linked list of funcstates */
fs->ls = ls;
fs->L = L;
ls->fs = fs;
fs->pc = 0;
fs->lasttarget = -1;
fs->jpc = NO_JUMP;
fs->freereg = 0;
fs->nk = 0;
fs->np = 0;
#if LUA_EXT_CONTINUE
fs->prohibitedloc = LUAI_MAXVARS + 1; /* nothing prohibited */
#endif /* LUA_EXT_CONTINUE */
fs->nlocvars = 0;
fs->nactvar = 0;
fs->bl = NULL;
f->source = ls->source;
#if LUA_REFCOUNT
luarc_addrefstring(f->source);
#endif /* LUA_REFCOUNT */
f->maxstacksize = 2; /* registers 0/1 are always valid */
fs->h = luaH_new(L, 0, 0);
#if LUA_REFCOUNT
luarc_addreftable(fs->h);
#endif /* LUA_REFCOUNT */
/* anchor table of constants and prototype (to avoid being collected) */
sethvalue2s(L, L->top, fs->h);
incr_top(L);
setptvalue2s(L, L->top, f);
incr_top(L);
}
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 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++;
}
static Proto* LoadFunction(LoadState* S, TString* p)
{
Proto* f;
if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
f=luaF_newproto(S->L);
setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
f->source=LoadString(S); if (f->source==NULL) f->source=p;
#if LUA_REFCOUNT
luarc_addrefstring(f->source);
#endif /* LUA_REFCOUNT */
f->linedefined=LoadInt(S);
f->lastlinedefined=LoadInt(S);
f->nups=LoadByte(S);
f->numparams=LoadByte(S);
f->is_vararg=LoadByte(S);
f->maxstacksize=LoadByte(S);
LoadCode(S,f);
LoadConstants(S,f);
LoadDebug(S,f);
IF (!luaG_checkcode(f), "bad code");
S->L->top--;
S->L->nCcalls--;
return f;
}
