static int addk(FuncState *fs, Tvalue *key, Tvalue *v)
{
Tvalue *idx = ktapc_table_set(fs->h, key);
Proto *f = fs->f;
int k, oldsize;
if (ttisnumber(idx)) {
ktap_Number n = nvalue(idx);
ktap_number2int(k, n);
if (ktapc_equalobj(&f->k[k], v))
return k;
/* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
go through and create a new entry for this value */
}
/* constant not found; create a new entry */
oldsize = f->sizek;
k = fs->nk;
/* numerical value does not need GC barrier;
table has no metatable, so it does not need to invalidate cache */
setnvalue(idx, (ktap_Number)(k));
ktapc_growvector(f->k, k, f->sizek, Tvalue, MAXARG_Ax, "constants");
while (oldsize < f->sizek)
setnilvalue(&f->k[oldsize++]);
setobj(NULL, &f->k[k], v);
fs->nk++;
return k;
}
static void new_localvar(ktap_lexstate *ls, ktap_string *name)
{
ktap_funcstate *fs = ls->fs;
ktap_dyndata *dyd = ls->dyd;
int reg = registerlocalvar(ls, name);
checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
MAXVARS, "local variables");
ktapc_growvector(dyd->actvar.arr, dyd->actvar.n + 1,
dyd->actvar.size, ktap_vardesc, MAX_INT, "local variables");
dyd->actvar.arr[dyd->actvar.n++].idx = (short)reg;
}
static int newlabelentry(ktap_lexstate *ls, ktap_labellist *l, ktap_string *name,
int line, int pc)
{
int n = l->n;
ktapc_growvector(l->arr, n, l->size,
ktap_labeldesc, SHRT_MAX, "labels/gotos");
l->arr[n].name = name;
l->arr[n].line = line;
l->arr[n].nactvar = ls->fs->nactvar;
l->arr[n].pc = pc;
l->n++;
return n;
}
static int registerlocalvar(ktap_lexstate *ls, ktap_string *varname)
{
ktap_funcstate *fs = ls->fs;
ktap_proto *f = fs->f;
int oldsize = f->sizelocvars;
ktapc_growvector(f->locvars, fs->nlocvars, f->sizelocvars,
ktap_locvar, SHRT_MAX, "local variables");
while (oldsize < f->sizelocvars)
f->locvars[oldsize++].varname = NULL;
f->locvars[fs->nlocvars].varname = varname;
return fs->nlocvars++;
}
static int registerlocalvar(LexState *ls, Tstring *varname)
{
FuncState *fs = ls->fs;
Proto *f = fs->f;
int oldsize = f->sizelocvars;
ktapc_growvector(f->locvars, fs->nlocvars, f->sizelocvars,
LocVar, SHRT_MAX, "local variables");
while (oldsize < f->sizelocvars)
f->locvars[oldsize++].varname = NULL;
f->locvars[fs->nlocvars].varname = varname;
return fs->nlocvars++;
}
static int newupvalue(ktap_funcstate *fs, ktap_string *name, ktap_expdesc *v)
{
ktap_proto *f = fs->f;
int oldsize = f->sizeupvalues;
checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
ktapc_growvector(f->upvalues, fs->nups, f->sizeupvalues,
ktap_upvaldesc, MAXUPVAL, "upvalues");
while (oldsize < f->sizeupvalues)
f->upvalues[oldsize++].name = NULL;
f->upvalues[(int)fs->nups].instack = (v->k == VLOCAL);
f->upvalues[(int)fs->nups].idx = (u8)(v->u.info);
f->upvalues[(int)fs->nups].name = name;
return fs->nups++;
}
static int codegen_code(FuncState *fs, Instruction i)
{
Proto *f = fs->f;
dischargejpc(fs); /* `pc' will change */
/* put new instruction in code array */
ktapc_growvector(f->code, fs->pc, f->sizecode, Instruction,
MAX_INT, "opcodes");
f->code[fs->pc] = i;
/* save corresponding line information */
ktapc_growvector(f->lineinfo, fs->pc, f->sizelineinfo, int,
MAX_INT, "opcodes");
f->lineinfo[fs->pc] = fs->ls->lastline;
return fs->pc++;
}
