int luaK_exp2RK (FuncState *fs, expdesc *e) {
luaK_exp2val(fs, e);
switch (e->k) {
case VTRUE:
case VFALSE:
case VNIL: {
if (fs->nk <= MAXINDEXRK) { /* constant fits in RK operand? */
e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
e->k = VK;
return RKASK(e->u.info);
}
else break;
}
case VKINT: {
e->u.info = luaK_intK(fs, e->u.ival);
e->k = VK;
goto vk;
}
case VKFLT: {
e->u.info = luaK_numberK(fs, e->u.nval);
e->k = VK;
/* go through */
}
case VK: {
vk:
if (e->u.info <= MAXINDEXRK) /* constant fits in argC? */
return RKASK(e->u.info);
else break;
}
default: break;
}
/* not a constant in the right range: put it in a register */
return luaK_exp2anyreg(fs, e);
}
static Proto* combine(lua_State* L, int scripts) {
if (scripts==1 && preloads==0)
return toproto(L,-1);
else {
TString *s;
TValue *k;
int i,pc,n;
Proto* f=luaF_newproto(L);
setptvalue2s(L,L->top,f); incr_top(L);
f->source=luaS_newliteral(L,"=(" PROGNAME ")");
f->maxstacksize=1;
pc=(2*scripts) + 1;
if(preloads > 0) {
pc+=(2*preloads) + 2;
}
f->code=luaM_newvector(L,pc,Instruction);
f->sizecode=pc;
n=(scripts + preloads);
f->p=luaM_newvector(L,n,Proto*);
f->sizep=n;
pc=0;
n=0;
/* preload libraries. */
if (preloads > 0) {
/* create constants array. */
f->k=luaM_newvector(L, (preloads + 2),TValue);
f->sizek=(preloads + 2);
/* make room for "local t" variable. */
f->maxstacksize=2;
/* add "package" & "preload" constants. */
k=&(f->k[0]);
s=luaS_newliteral(L, "package");
setsvalue2n(L,k,s);
k=&(f->k[1]);
s=luaS_newliteral(L, "preload");
setsvalue2n(L,k,s);
/* code: local t = package.preload */
f->code[pc++]=CREATE_ABx(OP_GETGLOBAL,0,0);
f->code[pc++]=CREATE_ABC(OP_GETTABLE,0,0,RKASK(1));
}
/* add preload libraries to "package.preload" */
for (i=0; i < preloads; i++) {
/* create constant for library name. */
k=&(f->k[i+2]);
s=luaS_new(L, preload_libs[i]);
setsvalue2n(L,k,s);
/* code: t['name'] = function() --[[ lib code ]] end */
f->code[pc++]=CREATE_ABx(OP_CLOSURE,1,n);
f->code[pc++]=CREATE_ABC(OP_SETTABLE,0,RKASK(i+2),1);
f->p[n++]=toproto(L,i-preloads-1);
}
/* call scripts. */
for (i=0; i < scripts; i++) {
/* code: (function() --[[ script code ]] end)() */
f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,n);
f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
f->p[n++]=toproto(L,i-scripts-1-preloads);
}
f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
return f;
}
}
/*
* If the luac command line includes multiple files or has the -f option
* then luac generates a main function to reference all sub-main prototypes.
* This is one of two types:
* Type 0 The standard luac combination main
* Type 1 A lookup wrapper that facilitates indexing into the generated protos
*/
static const Proto* combine(lua_State* L, int n, int type)
{
if (n==1 && type == 0)
return toproto(L,-1);
else
{
int i;
Instruction *pc;
Proto* f=luaF_newproto(L);
setptvalue2s(L,L->top,f); incr_top(L);
f->source=luaS_newliteral(L,"=(" PROGNAME ")");
f->p=luaM_newvector(L,n,Proto*);
f->sizep=n;
for (i=0; i<n; i++)
f->p[i]=toproto(L,i-n-1);
pc=0;
if (type == 0) {
/*
* Type 0 is as per the standard luac, which is just a main routine which
* invokes all of the compiled functions sequentially. This is fine if
* they are self registering modules, but useless otherwise.
*/
f->numparams = 0;
f->maxstacksize = 1;
f->sizecode = 2*n + 1 ;
f->sizek = 0;
f->code = luaM_newvector(L, f->sizecode , Instruction);
f->k = luaM_newvector(L,f->sizek,TValue);
for (i=0, pc = f->code; i<n; i++) {
*pc++ = CREATE_ABx(OP_CLOSURE,0,i);
*pc++ = CREATE_ABC(OP_CALL,0,1,1);
}
*pc++ = CREATE_ABC(OP_RETURN,0,1,0);
} else {
/*
* The Type 1 main() is a lookup which takes a single argument, the name to
* be resolved. If this matches root name of one of the compiled files then
* a closure to this file main is returned. Otherwise the Unixtime of the
* compile and the list of root names is returned.
*/
if (n > LFIELDS_PER_FLUSH) {
#define NO_MOD_ERR_(n) ": Number of modules > " #n
#define NO_MOD_ERR(n) NO_MOD_ERR_(n)
usage(LUA_QL("-f") NO_MOD_ERR(LFIELDS_PER_FLUSH));
}
f->numparams = 1;
f->maxstacksize = n + 3;
f->sizecode = 5*n + 5 ;
f->sizek = n + 1;
f->sizelocvars = 0;
f->code = luaM_newvector(L, f->sizecode , Instruction);
f->k = luaM_newvector(L,f->sizek,TValue);
for (i=0, pc = f->code; i<n; i++)
{
/* if arg1 == FnameA then return function (...) -- funcA -- end end */
setsvalue2n(L,f->k+i,corename(L, f->p[i]->source));
*pc++ = CREATE_ABC(OP_EQ,0,0,RKASK(i));
*pc++ = CREATE_ABx(OP_JMP,0,MAXARG_sBx+2);
*pc++ = CREATE_ABx(OP_CLOSURE,1,i);
*pc++ = CREATE_ABC(OP_RETURN,1,2,0);
}
setnvalue(f->k+n, (lua_Number) time(NULL));
*pc++ = CREATE_ABx(OP_LOADK,1,n);
*pc++ = CREATE_ABC(OP_NEWTABLE,2,luaO_int2fb(i),0);
for (i=0; i<n; i++)
*pc++ = CREATE_ABx(OP_LOADK,i+3,i);
*pc++ = CREATE_ABC(OP_SETLIST,2,i,1);
*pc++ = CREATE_ABC(OP_RETURN,1,3,0);
*pc++ = CREATE_ABC(OP_RETURN,0,1,0);
}
lua_assert((pc-f->code) == f->sizecode);
return f;
}
}
