Lua源码分析 - 主流程篇 - 函数调用栈的实现（08）

 

目录

函数调用栈 - 从main方法看函数调用栈

函数调用栈 - 函数调用主流程详解

调用栈操作 - 保护方式lua_pcallk函数调用

调用栈操作 - 主函数luaD_call逻辑详解

调用栈操作 - 结果集moveresults调整

---

前面几章我们介绍了Lua常用的最重要的几个数据结构。这章节开始，我们开始讲解主流程篇。

主流程，一般都是从lua.c的main方法开始。那我们就从main方法开始看整个链路和流程。

函数调用栈 - 从main方法看函数调用栈

从main方法中，创建完基础的lua_State *L结构后，我们就能看到Lua向数据栈上push了一个c语言的闭包方法。该方法：pmain。

• pmain方法是整个Lua执行流最核心的方法。主要负责：命令行参数的解析、Lua语言默认库的加载、Lua脚本语言的解析和调用等。
• Lua的栈操作主要靠lua_push*系列函数，往栈上不同压入不同的数据。
• main函数中首先压入pmain方法，然后把命令行参数个数和命令行参数数据也压入到了Lua的栈上。然后通过lua_pcall方法，开始执行pmain函数。
• lua_pcall方法为何调用的是pmain函数，而不是其他函数。其实调用的函数就是我们Lua栈执行函数= L->top - (nargs+1); 在lua_pcall中就能详细看到。
• 当调用pmain函数的时候，pmain首先会去解析命令行参数，然后加载默认的Lua语言的API函数库，再然后加载lua脚本文件以及解析lua语言，最后如果pmain方法执行成功，需要将status状态push放入栈顶（lua_pushboolean）。
• main方法中，通过lua_toboolean从当前调用栈CallInfo上获取结果值。

看一下具体实现：

/**
 * argc：行参数的个数
 * argv：每个参数的值，指针结构
 */
int main (int argc, char **argv) {
  int status, result;
  /* 第一步：创建一个主线程栈数据结构 */
  lua_State *L = luaL_newstate();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  lua_pushcfunction(L, &pmain);  /* 将pmain放入L结构上 L->top值&pmain*/
  lua_pushinteger(L, argc);  /* 将argc 放入L结构上  L->top值argc*/
  lua_pushlightuserdata(L, argv); /* 将argv 放入L结构上 L->top值argv*/
  status = lua_pcall(L, 2, 1, 0);  /* 函数操作，执行pmain 函数 do the call */
  result = lua_toboolean(L, -1);  /* 获取pmain函数lua_pushboolean(L, 1) 的信号值get result */
  report(L, status);
  lua_close(L);
  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
}

static int pmain (lua_State *L) {
   .......省.......

  /* 打开常规Lua的标准库 */
  luaL_openlibs(L);  /* open standard libraries */

  .......省.......
  else dofile(L, NULL);  /* executes stdin as a file */

  .......省.......
  lua_pushboolean(L, 1);  /* 向栈顶L->top PUSH 返回值signal no errors */
  return 1;
}

具体pmain函数的调用，可以看下图：

 

函数调用栈 - 函数调用主流程详解

具体的整个函数调用栈操作流程如下（可以参考图片中的文件顺序进行源码阅读）：

• 首先Lua mian函数中，通过lua_push*系列函数将调用的函数以及参数数据进行入栈操作。
• Lua会调用lua_pcall执行Lua函数的真正调用。lua_pcall函数通过参数的个数和结果个数进行数据校验，以及拿到函数栈的StkId地址。lua_pcallk和lua_callk函数都在lapi.c文件中，两个函数的区别是一个有异常保护，一个没有异常保护。无论是保护状态下，还是非保护状态下，最终都是调用luaD_call函数（Lua的函数调用执行操作都在ldo.c文件中）。
• luaD_call函数中，首先会调用luaD_precall预处理函数。luaD_precall预处理函数主要会创建一个调用栈CallInfo，管理函数调用时的信息。CallInfo是一个双向链表形式管理。每次有新的函数进来，都会用新的CallInfo进行函数调用信息管理。
• Lua的函数调用一共分三种：C语言闭包函数（例如pmain），Lua的API函数库（例如字符串strlen函数），Lua语言解析。
• 如果是c语言闭包函数和Lua的API函数：会直接执行C方法（方法入参都为L），并调用luaD_poscall，调整堆栈，返回上一个调用栈。（我们语言中，肯定是一个函数内会嵌套N个函数。每次执行完一个函数后，都会返回到上一层CallInfo（L->ci会变更为上一层CallInfo），然后继续执行该函数的其它事务。）
• 如果是Lua语言，则会调用luaV_execute执行语言字节码调用。在luaV_execute函数中，当遇到函数调用尾部OP_TAILCALL的时候，则会调整CallInfo堆栈，返回上一个调用栈
• 如果你有返回值，在被执行的函数中通过lua_push*系列函数，将函数结果返回到栈顶部即可。外部可以通过lua_to*系列函数，获取当前调用栈的栈顶数据信息。
• 最后，在luaD_poscall函数中，会调用moveresults方法，该方法主要用于调整返回结果，将结果集调整到CallInfo函数的起始位置ci->func，并调整L->top。说白了，一个CallInfo调整完毕之后，只需要将得到的结果集返回到堆栈上，并调整堆栈，保障整体的堆栈回调大小控制在一定范围内。

 

调用栈操作 - 保护方式lua_pcallk函数调用

在lapi.c文件中，lua_pcallk方法是受保护的调用方式，lua_callk为非受保护的调用方式。受保护方法的唯一区别：函数的调用都不会因为错误直接导致程序直接退出，而是退回到调用点，然后将状态返回到外层的逻辑处理。

我们可以看一下ldo.c文件中的luaD_pcall方法。该方法最终调用luaD_rawrunprotected，而luaD_rawrunprotected实际最终调用f_call函数。保护性调用的情况下lua虚拟机使用lua_longjmp为函数实现堆栈续传功能，也就是当错误发生的时候，在Lua内部能够最终跳转到调用点继续向下执行。详见：《Lua源码分析 - 主流程篇 - 异常处理机制实现（09）》

/**
 * 函数调用主方法（异常保护方式）
 * func：f_call方法
 * u：CallS 调用的方法等信息
 * old_top：函数调用前的栈顶 L->top
 * ef：错误状态
 */
int luaD_pcall (lua_State *L, Pfunc func, void *u,
                ptrdiff_t old_top, ptrdiff_t ef) {
  int status;
  CallInfo *old_ci = L->ci; //老的函数回调CallInfo
  lu_byte old_allowhooks = L->allowhook; //是否允许钩子
  unsigned short old_nny = L->nny;
  ptrdiff_t old_errfunc = L->errfunc;
  L->errfunc = ef;
  status = luaD_rawrunprotected(L, func, u); //异常保护调用主函数

  /* 处理失败，栈状态回滚？ */
  if (status != LUA_OK) {  /* an error occurred? */
    StkId oldtop = restorestack(L, old_top);
    luaF_close(L, oldtop);  /* close possible pending closures */
    seterrorobj(L, status, oldtop);
    L->ci = old_ci;
    L->allowhook = old_allowhooks;
    L->nny = old_nny;
    luaD_shrinkstack(L);
  }
  L->errfunc = old_errfunc;
  return status;
}

/**
 * 保护性调用（最终回调luaD_callnoyield方法）
 * f=luaD_callnoyield方法
 * ud=CallS *c   （ c->func, c->nresults）
 */
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
  unsigned short oldnCcalls = L->nCcalls;
  struct lua_longjmp lj;
  lj.status = LUA_OK;
  lj.previous = L->errorJmp;  /* chain new error handler */
  L->errorJmp = &lj;
  LUAI_TRY(L, &lj,
    (*f)(L, ud);
  );
  L->errorJmp = lj.previous;  /* restore old error handler */
  L->nCcalls = oldnCcalls;
  return lj.status;
}

/**
 * 该方法包了很多层，最终调用luaD_call方法
 */
static void f_call (lua_State *L, void *ud) {
  struct CallS *c = cast(struct CallS *, ud);
  luaD_callnoyield(L, c->func, c->nresults);
}

/*
** Similar to 'luaD_call', but does not allow yields during the call
** 不允许挂起
*/
void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
  L->nny++;
  luaD_call(L, func, nResults);
  L->nny--;
}

调用栈操作 - 主函数luaD_call逻辑详解

无论是保护模式还是非保护模式下，最终会调用luaD_call方法。

该方法会先调用luaD_precall函数，对Lua函数执行作预处理。预处理主要作用是调整：调用栈CallInfo的堆栈

预处理函数主要逻辑：

• 检查栈信息，创建一个新的CallInfo 容器，填充相关的信息
• 如果是C语言闭包函数 or Lua的C语言 API函数库，则直接执行函数（PS：这些函数入参都统一为L）
• 如果是Lua语言，则进行CallInfo预处理之后，直接调用luaV_execute函数，执行虚拟机的指令集。
• 不论是C语言函数还是Lua语言函数，函数执行完毕后都会进行堆栈调整，将正在执行的操作站CallInfo指针会往上一层调用栈调整。C语言函数会调用luaD_poscall调整堆栈。而Lua语言则在虚拟机指令集运行中，找到函数调用尾部OP_TAILCALL的时候，会调整整体堆栈。

/*
** Call a function (C or Lua). The function to be called is at *func.
** The arguments are on the stack, right after the function.
** When returns, all the results are on the stack, starting at the original
** function position.
** 真正执行一个C语言方法 or 一个Lua方法
*/
void luaD_call (lua_State *L, StkId func, int nResults) {
  if (++L->nCcalls >= LUAI_MAXCCALLS)
    stackerror(L);
  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
    luaV_execute(L);  /* call it Lua方法，则执行字节码方式 */
  L->nCcalls--;
}

/*
** Prepares a function call: checks the stack, creates a new CallInfo
** entry, fills in the relevant information, calls hook if needed.
** If function is a C function, does the call, too. (Otherwise, leave
** the execution ('luaV_execute') to the caller, to allow stackless
** calls.) Returns true iff function has been executed (C function).
** 预处理一个方法call
** 1. 检查栈信息
** 2. 创建一个新的CallInfo 容器
** 3. 填充相关的信息
** 4. 如果需要，回调钩子函数
*/
int luaD_precall (lua_State *L, StkId func, int nresults) {
  lua_CFunction f;
  CallInfo *ci;
  switch (ttype(func)) {
    case LUA_TCCL:  /* C语言闭包 C closure */
      f = clCvalue(func)->f;
      goto Cfunc;
    case LUA_TLCF:  /* C语言函数 light C function */
      f = fvalue(func);
     Cfunc: {
      int n;  /* number of returns */
      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
      ci = next_ci(L);  /* 创建一个新的CallInfo栈对象 now 'enter' new function */
      ci->nresults = nresults; //返回的结果个数
      ci->func = func; //指向需要调用的函数栈
      ci->top = L->top + LUA_MINSTACK; //C语言方法最小的调用栈允许20
      lua_assert(ci->top <= L->stack_last);
      ci->callstatus = 0;
      if (L->hookmask & LUA_MASKCALL)
        luaD_hook(L, LUA_HOOKCALL, -1);
      lua_unlock(L);
      n = (*f)(L);  /* 直接调用C语言闭包函数 do the actual call */
      lua_lock(L);
      api_checknelems(L, n);
      luaD_poscall(L, ci, L->top - n, n); //调整堆栈
      return 1; //返回1 C语言本身函数
    }
    case LUA_TLCL: {  /* Lua方法 Lua function: prepare its call */
      StkId base;
      Proto *p = clLvalue(func)->p;
      int n = cast_int(L->top - func) - 1;  /* number of real arguments */
      int fsize = p->maxstacksize;  /* frame size */
      checkstackp(L, fsize, func);
      if (p->is_vararg)
        base = adjust_varargs(L, p, n);
      else {  /* non vararg function */
        for (; n < p->numparams; n++)
          setnilvalue(L->top++);  /* complete missing arguments */
        base = func + 1;
      }
      ci = next_ci(L);  /* now 'enter' new function */
      ci->nresults = nresults;
      ci->func = func;
      ci->u.l.base = base;
      L->top = ci->top = base + fsize;
      lua_assert(ci->top <= L->stack_last);
      ci->u.l.savedpc = p->code;  /* starting point */
      ci->callstatus = CIST_LUA;
      if (L->hookmask & LUA_MASKCALL)
        callhook(L, ci);
      return 0; //返回0，Lua函数
    }
    default: {  /* not a function */
      checkstackp(L, 1, func);  /* ensure space for metamethod */
      tryfuncTM(L, func);  /* try to get '__call' metamethod */
      return luaD_precall(L, func, nresults);  /* now it must be a function */
    }
  }
}

 

调用栈操作 - 结果集moveresults调整

函数调用结束后，首先CI会回滚到上一层的调用，并调用moveresults函数，调整结果集数据。

• moveresults会将结果集（0个/1个/多个），逐个根据顺序拷贝到ci->func位置，并调整L->top的指针位置。如下图。
• 一个函数调用完毕之后，只需要将得到的结果集返回给上一层，并调整堆栈top指针，保障整体的堆栈回调大小控制在一定范围内。
• 返回值是我们回调函数里面，通过lua_push*方法向栈顶设置返回值。如果回调函数中没有设定返回值，则首个返回的结果为最后一个参数。

/*
** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
** Handle most typical cases (zero results for commands, one result for
** expressions, multiple results for tail calls/single parameters)
** separated.
*/
static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
                                      int nres, int wanted) {
  switch (wanted) {  /* handle typical cases separately */
    case 0: break;  /* nothing to move */
    case 1: {  /* one result needed */
      if (nres == 0)   /* no results? */
        firstResult = luaO_nilobject;  /* adjust with nil */
      setobjs2s(L, res, firstResult);  /* move it to proper place */
      break;
    }
    case LUA_MULTRET: {
      int i;
      for (i = 0; i < nres; i++)  /* move all results to correct place */
        setobjs2s(L, res + i, firstResult + i);
      L->top = res + nres;
      return 0;  /* wanted == LUA_MULTRET */
    }
    default: {
      int i;
      if (wanted <= nres) {  /* enough results? */
        for (i = 0; i < wanted; i++)  /* move wanted results to correct place */
          setobjs2s(L, res + i, firstResult + i);
      }
      else {  /* not enough results; use all of them plus nils */
        for (i = 0; i < nres; i++)  /* move all results to correct place */
          setobjs2s(L, res + i, firstResult + i);
        for (; i < wanted; i++)  /* complete wanted number of results */
          setnilvalue(res + i);
      }
      break;
    }
  }
  L->top = res + wanted;  /* top points after the last result */
  return 1;
}