Lua2.4 执行之前 opcode.c
上节说到了 lua_dofile 执行脚本文件，或者编译过的脚本二进制文件。
这节看下，Lua 是如何区别这两种文件的，以及虚拟机在开始执行字节码之前，程序里面都发生了什么？
lua.c 里面的调用了 lua_dofile 来执行文件，看下 lua_dofile
/*
** Open file, generate opcode and execute global statement. Return 0 on
** success or 1 on error.
*/
int lua_dofile (char *filename)
{
int status;
int c;
FILE *f = lua_openfile(filename);
if (f == NULL)
return 1;
c = fgetc(f);
ungetc(c, f);
status = (c == ID_CHUNK) ? luaI_undump(f) : do_protectedmain();
lua_closefile();
return status;
}
注释里写得很清楚，这个函数是用来打开文件，生成字节码，执行全局的语句。
成功返回 0 ，失败返回 1 。
lua_openfile 打开文件部分已经在编译器分析的时候说过了，这里就不再重复了（后面再遇到这样的已经分析过的可能就不再说明，直接略过了。）。
看下面的
c = fgetc(f); ungetc(c, f);
这两句是读取文件的第一个字符，然后再把该字符放回到文件输入流中去，使输入流的还是保持在文件头的位置（也就是尚未读取的状态）。
接下来的这一句
status = (c == ID_CHUNK) ? luaI_undump(f) : do_protectedmain();
就是检查刚才读到那个字符。在编译器分析时，我们知道编译器生成的 *.out 二进制文件的开头第一个字符就是 ID_CHUNK ，ASCII 码为 27 。而在正常的脚本文件中，这个字符是不会出现的。所以可以根据这个标签来判定文件是个 *.out 的二进制文件或者是个脚本文件。
如果是编译过的二进制文件，调用 luaI_undump 恢复场景并执行。
/*
** load and run all chunks in a file
*/
int luaI_undump(FILE* D)
{
TFunc* m;
while ((m=luaI_undump1(D)))
{
int status=luaI_dorun(m);
luaI_freefunc(m);
if (status!=0) return status;
}
return 0;
}
这里可以看到，luaI_undump 先是调用 luaI_undump1 恢复场景，至于怎么恢复场景的，下节再说。
恢复之后，调用 luaI_dorun 。
回到 lua_dofile，如果是一个脚本文件的话，调用 do_protectedmain。
static int do_protectedmain (void)
{
TFunc tf;
int status;
jmp_buf myErrorJmp;
jmp_buf *oldErr = errorJmp;
errorJmp = &myErrorJmp;
luaI_initTFunc(&tf);
tf.fileName = lua_parsedfile;
if (setjmp(myErrorJmp) == 0)
{
lua_parse(&tf);
status = luaI_dorun(&tf);
}
else
{
status = 1;
adjustC(0); /* erase extra slot */
}
errorJmp = oldErr;
luaI_free(tf.code);
return status;
}
这里我们看到，在做一些初始化，和设置异常恢复断点之后，语法分析 lua_parse 之后，它也是调用了 luaI_dorun ，调到这一步的时候，编译过二进制文件和脚本文件就没有差别了。setjmp 可以先简单的认为是 C 语言版的 try...catch 异常处理, 虽然它们之间是有区别的。
后面代码是做一些异常发生的善后处理，设置状态位，释放相关的资源。
int luaI_dorun (TFunc *tf)
{
int status;
adjustC(1); /* one slot for the pseudo-function */
stack[CBase].tag = LUA_T_FUNCTION;
stack[CBase].value.tf = tf;
status = do_protectedrun(0);
adjustC(0);
return status;
}
把编译好的 TFunc 设置到栈上，调用 do_protectedrun。
/*
** Execute a protected call. Assumes that function is at CBase and
** parameters are on top of it. Leave nResults on the stack.
*/
static int do_protectedrun (int nResults)
{
jmp_buf myErrorJmp;
int status;
StkId oldCBase = CBase;
jmp_buf *oldErr = errorJmp;
errorJmp = &myErrorJmp;
if (setjmp(myErrorJmp) == 0)
{
do_call(CBase+1, nResults);
CnResults = (top-stack) - CBase; /* number of results */
CBase += CnResults; /* incorporate results on the stack */
status = 0;
}
else
{ /* an error occurred: restore CBase and top */
CBase = oldCBase;
top = stack+CBase;
status = 1;
}
errorJmp = oldErr;
return status;
}
注释比较清楚，不再细说。函数名字中有 protected 字样的就是受保护的调用，内部使用 setjmp 来设置异常恢复点。函数调用 do_call 执行刚才压栈的 TFunc.
/*
** Call a function (C or Lua). The parameters must be on the stack,
** between [stack+base,top). The function to be called is at stack+base-1.
** When returns, the results are on the stack, between [stack+base-1,top).
** The number of results is nResults, unless nResults=MULT_RET.
*/
static void do_call (StkId base, int nResults)
{
StkId firstResult;
Object *func = stack+base-1;
int i;
if (tag(func) == LUA_T_CFUNCTION)
{
tag(func) = LUA_T_CMARK;
firstResult = callC(fvalue(func), base);
}
else if (tag(func) == LUA_T_FUNCTION)
{
tag(func) = LUA_T_MARK;
firstResult = lua_execute(func->value.tf->code, base);
}
else
{ /* func is not a function */
/* Call the fallback for invalid functions */
open_stack((top-stack)-(base-1));
stack[base-1] = luaI_fallBacks[FB_FUNCTION].function;
do_call(base, nResults);
return;
}
/* adjust the number of results */
if (nResults != MULT_RET && top - (stack+firstResult) != nResults)
adjust_top(firstResult+nResults);
/* move results to base-1 (to erase parameters and function) */
base--;
nResults = top - (stack+firstResult); /* actual number of results */
for (i=0; i<nResults; i++)
*(stack+base+i) = *(stack+firstResult+i);
top -= firstResult-base;
}
判断栈上的是 C 函数还是，Lua 的函数。
如果是 C 的调用 callC。
如果是 Lua 的函数，则调用 lua_execute 由虚拟机执行。
如果不是一个函数，则调用 "function" 的回退函数。
之后，是调整返回值和栈。
调整栈有一个简单的规则就是：函数调用后栈的状态要和函数调用前保持一样，除了可能在栈上剩下几个返回值。这句话可能不容易理解，举个小例子。比如在 C 语言里，我们有一个函数:
int add(int a, int b)
{
return a + b;
}
如果我们有一个调用 int result = add(3, 5)，在这句执行完后，它所产生的效果和 int result = 8 是完全一样的。套到这里就是，在该调用 add(3, 5) 的地方，你直接放个 8 到栈上去效果是一样的，对于后续程序的执行完全没有任何影响。
回忆一下汇编里的函数调用返回的栈桢结构，是不是觉得这里的函数调用返回有点眼熟了。
callC 就是调用一个 C 的函数指针。
lua_execute 是一个很大的 switch...case 来执行指令。这个在之前的版本里有详细介绍，在这个版本里可能就略过了。
fallback 对程序的主流程基本没什么影响。
----------------------------------------
到目前为止的问题：
> luaI_undump1 怎么恢复场景的
----------------------------------------