lua解释执行脚本流程

 1 #include "lua.hpp"
 2 
 3 #include <iostream>
 4 using namespace std;
 5 
 6 #pragma comment(lib, "lua5.1.lib")
 7 
 8 struct lua_guard{
 9     lua_State *pL;
10     lua_guard(lua_State *s) :pL(s){}
11     ~lua_guard(){ lua_close(pL); }
12 };
13 
14 int main(){
15     lua_guard g(lua_open());
16     luaL_openlibs(g.pL);
17     int err;
18     if ((err = luaL_dofile(g.pL, "mylua.lua") != 0)){
19         throw runtime_error("open lua file error");
20     }
21     system("pause");
22     return 0;
23 }

  1 void luaV_execute (lua_State *L, int nexeccalls) {
  2   LClosure *cl;
  3   StkId base;
  4   TValue *k;
  5   const Instruction *pc;
  6  reentry:  /* entry point */
  7   lua_assert(isLua(L->ci));
  8   pc = L->savedpc;
  9   cl = &clvalue(L->ci->func)->l;
 10   base = L->base;
 11   k = cl->p->k;
 12   /* main loop of interpreter */
 13   for (;;) {
 14     const Instruction i = *pc++;
 15     StkId ra;
 16     if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
 17         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
 18       traceexec(L, pc);
 19       if (L->status == LUA_YIELD) {  /* did hook yield? */
 20         L->savedpc = pc - 1;
 21         return;
 22       }
 23       base = L->base;
 24     }
 25     /* warning!! several calls may realloc the stack and invalidate `ra‘ */
 26     ra = RA(i);
 27     lua_assert(base == L->base && L->base == L->ci->base);
 28     lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
 29     lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
 30     switch (GET_OPCODE(i)) {
 31       case OP_MOVE: {
 32         setobjs2s(L, ra, RB(i));
 33         continue;
 34       }
 35       case OP_LOADK: {
 36         setobj2s(L, ra, KBx(i));
 37         continue;
 38       }
 39       case OP_LOADBOOL: {
 40         setbvalue(ra, GETARG_B(i));
 41         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
 42         continue;
 43       }
 44       case OP_LOADNIL: {
 45         TValue *rb = RB(i);
 46         do {
 47           setnilvalue(rb--);
 48         } while (rb >= ra);
 49         continue;
 50       }
 51       case OP_GETUPVAL: {
 52         int b = GETARG_B(i);
 53         setobj2s(L, ra, cl->upvals[b]->v);
 54         continue;
 55       }
 56       case OP_GETGLOBAL: {
 57         TValue g;
 58         TValue *rb = KBx(i);
 59         sethvalue(L, &g, cl->env);
 60         lua_assert(ttisstring(rb));
 61         Protect(luaV_gettable(L, &g, rb, ra));
 62         continue;
 63       }
 64       case OP_GETTABLE: {
 65         Protect(luaV_gettable(L, RB(i), RKC(i), ra));
 66         continue;
 67       }
 68       case OP_SETGLOBAL: {
 69         TValue g;
 70         sethvalue(L, &g, cl->env);
 71         lua_assert(ttisstring(KBx(i)));
 72         Protect(luaV_settable(L, &g, KBx(i), ra));
 73         continue;
 74       }
 75       case OP_SETUPVAL: {
 76         UpVal *uv = cl->upvals[GETARG_B(i)];
 77         setobj(L, uv->v, ra);
 78         luaC_barrier(L, uv, ra);
 79         continue;
 80       }
 81       case OP_SETTABLE: {
 82         Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
 83         continue;
 84       }
 85       case OP_NEWTABLE: {
 86         int b = GETARG_B(i);
 87         int c = GETARG_C(i);
 88         sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
 89         Protect(luaC_checkGC(L));
 90         continue;
 91       }
 92       case OP_SELF: {
 93         StkId rb = RB(i);
 94         setobjs2s(L, ra+1, rb);
 95         Protect(luaV_gettable(L, rb, RKC(i), ra));
 96         continue;
 97       }
 98       case OP_ADD: {
 99         arith_op(luai_numadd, TM_ADD);
100         continue;
101       }
102       case OP_SUB: {
103         arith_op(luai_numsub, TM_SUB);
104         continue;
105       }
106       case OP_MUL: {
107         arith_op(luai_nummul, TM_MUL);
108         continue;
109       }
110       case OP_DIV: {
111         arith_op(luai_numdiv, TM_DIV);
112         continue;
113       }
114       case OP_MOD: {
115         arith_op(luai_nummod, TM_MOD);
116         continue;
117       }
118       case OP_POW: {
119         arith_op(luai_numpow, TM_POW);
120         continue;
121       }
122       case OP_UNM: {
123         TValue *rb = RB(i);
124         if (ttisnumber(rb)) {
125           lua_Number nb = nvalue(rb);
126           setnvalue(ra, luai_numunm(nb));
127         }
128         else {
129           Protect(Arith(L, ra, rb, rb, TM_UNM));
130         }
131         continue;
132       }
133       case OP_NOT: {
134         int res = l_isfalse(RB(i));  /* next assignment may change this value */
135         setbvalue(ra, res);
136         continue;
137       }
138       case OP_LEN: {
139         const TValue *rb = RB(i);
140         switch (ttype(rb)) {
141           case LUA_TTABLE: {
142             setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
143             break;
144           }
145           case LUA_TSTRING: {
146             setnvalue(ra, cast_num(tsvalue(rb)->len));
147             break;
148           }
149           default: {  /* try metamethod */
150             Protect(
151               if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
152                 luaG_typeerror(L, rb, "get length of");
153             )
154           }
155         }
156         continue;
157       }
158       case OP_CONCAT: {
159         int b = GETARG_B(i);
160         int c = GETARG_C(i);
161         Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
162         setobjs2s(L, RA(i), base+b);
163         continue;
164       }
165       case OP_JMP: {
166         dojump(L, pc, GETARG_sBx(i));
167         continue;
168       }
169       case OP_EQ: {
170         TValue *rb = RKB(i);
171         TValue *rc = RKC(i);
172         Protect(
173           if (equalobj(L, rb, rc) == GETARG_A(i))
174             dojump(L, pc, GETARG_sBx(*pc));
175         )
176         pc++;
177         continue;
178       }
179       case OP_LT: {
180         Protect(
181           if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
182             dojump(L, pc, GETARG_sBx(*pc));
183         )
184         pc++;
185         continue;
186       }
187       case OP_LE: {
188         Protect(
189           if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
190             dojump(L, pc, GETARG_sBx(*pc));
191         )
192         pc++;
193         continue;
194       }
195       case OP_TEST: {
196         if (l_isfalse(ra) != GETARG_C(i))
197           dojump(L, pc, GETARG_sBx(*pc));
198         pc++;
199         continue;
200       }
201       case OP_TESTSET: {
202         TValue *rb = RB(i);
203         if (l_isfalse(rb) != GETARG_C(i)) {
204           setobjs2s(L, ra, rb);
205           dojump(L, pc, GETARG_sBx(*pc));
206         }
207         pc++;
208         continue;
209       }
210       case OP_CALL: {
211         int b = GETARG_B(i);
212         int nresults = GETARG_C(i) - 1;
213         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
214         L->savedpc = pc;
215         switch (luaD_precall(L, ra, nresults)) {
216           case PCRLUA: {
217             nexeccalls++;
218             goto reentry;  /* restart luaV_execute over new Lua function */
219           }
220           case PCRC: {
221             /* it was a C function (`precall‘ called it); adjust results */
222             if (nresults >= 0) L->top = L->ci->top;
223             base = L->base;
224             continue;
225           }
226           default: {
227             return;  /* yield */
228           }
229         }
230       }
231       case OP_TAILCALL: {
232         int b = GETARG_B(i);
233         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
234         L->savedpc = pc;
235         lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
236         switch (luaD_precall(L, ra, LUA_MULTRET)) {
237           case PCRLUA: {
238             /* tail call: put new frame in place of previous one */
239             CallInfo *ci = L->ci - 1;  /* previous frame */
240             int aux;
241             StkId func = ci->func;
242             StkId pfunc = (ci+1)->func;  /* previous function index */
243             if (L->openupval) luaF_close(L, ci->base);
244             L->base = ci->base = ci->func + ((ci+1)->base - pfunc);
245             for (aux = 0; pfunc+aux < L->top; aux++)  /* move frame down */
246               setobjs2s(L, func+aux, pfunc+aux);
247             ci->top = L->top = func+aux;  /* correct top */
248             lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
249             ci->savedpc = L->savedpc;
250             ci->tailcalls++;  /* one more call lost */
251             L->ci--;  /* remove new frame */
252             goto reentry;
253           }
254           case PCRC: {  /* it was a C function (`precall‘ called it) */
255             base = L->base;
256             continue;
257           }
258           default: {
259             return;  /* yield */
260           }
261         }
262       }
263       case OP_RETURN: {
264         int b = GETARG_B(i);
265         if (b != 0) L->top = ra+b-1;
266         if (L->openupval) luaF_close(L, base);
267         L->savedpc = pc;
268         b = luaD_poscall(L, ra);
269         if (--nexeccalls == 0)  /* was previous function running `here‘? */
270           return;  /* no: return */
271         else {  /* yes: continue its execution */
272           if (b) L->top = L->ci->top;
273           lua_assert(isLua(L->ci));
274           lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
275           goto reentry;
276         }
277       }
278       case OP_FORLOOP: {
279         lua_Number step = nvalue(ra+2);
280         lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
281         lua_Number limit = nvalue(ra+1);
282         if (luai_numlt(0, step) ? luai_numle(idx, limit)
283                                 : luai_numle(limit, idx)) {
284           dojump(L, pc, GETARG_sBx(i));  /* jump back */
285           setnvalue(ra, idx);  /* update internal index... */
286           setnvalue(ra+3, idx);  /* ...and external index */
287         }
288         continue;
289       }
290       case OP_FORPREP: {
291         const TValue *init = ra;
292         const TValue *plimit = ra+1;
293         const TValue *pstep = ra+2;
294         L->savedpc = pc;  /* next steps may throw errors */
295         if (!tonumber(init, ra))
296           luaG_runerror(L, LUA_QL("for") " initial value must be a number");
297         else if (!tonumber(plimit, ra+1))
298           luaG_runerror(L, LUA_QL("for") " limit must be a number");
299         else if (!tonumber(pstep, ra+2))
300           luaG_runerror(L, LUA_QL("for") " step must be a number");
301         setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
302         dojump(L, pc, GETARG_sBx(i));
303         continue;
304       }
305       case OP_TFORLOOP: {
306         StkId cb = ra + 3;  /* call base */
307         setobjs2s(L, cb+2, ra+2);
308         setobjs2s(L, cb+1, ra+1);
309         setobjs2s(L, cb, ra);
310         L->top = cb+3;  /* func. + 2 args (state and index) */
311         Protect(luaD_call(L, cb, GETARG_C(i)));
312         L->top = L->ci->top;
313         cb = RA(i) + 3;  /* previous call may change the stack */
314         if (!ttisnil(cb)) {  /* continue loop? */
315           setobjs2s(L, cb-1, cb);  /* save control variable */
316           dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
317         }
318         pc++;
319         continue;
320       }
321       case OP_SETLIST: {
322         int n = GETARG_B(i);
323         int c = GETARG_C(i);
324         int last;
325         Table *h;
326         if (n == 0) {
327           n = cast_int(L->top - ra) - 1;
328           L->top = L->ci->top;
329         }
330         if (c == 0) c = cast_int(*pc++);
331         runtime_check(L, ttistable(ra));
332         h = hvalue(ra);
333         last = ((c-1)*LFIELDS_PER_FLUSH) + n;
334         if (last > h->sizearray)  /* needs more space? */
335           luaH_resizearray(L, h, last);  /* pre-alloc it at once */
336         for (; n > 0; n--) {
337           TValue *val = ra+n;
338           setobj2t(L, luaH_setnum(L, h, last--), val);
339           luaC_barriert(L, h, val);
340         }
341         continue;
342       }
343       case OP_CLOSE: {
344         luaF_close(L, ra);
345         continue;
346       }
347       case OP_CLOSURE: {
348         Proto *p;
349         Closure *ncl;
350         int nup, j;
351         p = cl->p->p[GETARG_Bx(i)];
352         nup = p->nups;
353         ncl = luaF_newLclosure(L, nup, cl->env);
354         ncl->l.p = p;
355         for (j=0; j<nup; j++, pc++) {
356           if (GET_OPCODE(*pc) == OP_GETUPVAL)
357             ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
358           else {
359             lua_assert(GET_OPCODE(*pc) == OP_MOVE);
360             ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
361           }
362         }
363         setclvalue(L, ra, ncl);
364         Protect(luaC_checkGC(L));
365         continue;
366       }
367       case OP_VARARG: {
368         int b = GETARG_B(i) - 1;
369         int j;
370         CallInfo *ci = L->ci;
371         int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
372         if (b == LUA_MULTRET) {
373           Protect(luaD_checkstack(L, n));
374           ra = RA(i);  /* previous call may change the stack */
375           b = n;
376           L->top = ra + n;
377         }
378         for (j = 0; j < b; j++) {
379           if (j < n) {
380             setobjs2s(L, ra + j, ci->base - n + j);
381           }
382           else {
383             setnilvalue(ra + j);
384           }
385         }
386         continue;
387       }
388     }
389   }
390 }