C++实现与Lua相互调用的示例详解

概述

从本质上来看，其实说是不存在所谓的C++与lua的相互调用。lua是运行在C上的，简单来说lua的代码会被编译成字节码在被C语言的语法运行。在C++调用lua时，其实是解释运行lua文件编译出来的字节码。lua调用C++其实还是解释运行lua文件编译出来的字节码的语义是调用lua栈上的C++函数。

示例

来看下面这段代码：

C++

 
#include "Inc/lua.h"
#include "Inc/lauxlib.h"
#include "Inc/lualib.h"
#include "Inc/lobject.h"
}
 
using std::cout;
using std::endl;
 
int CAdd(lua_State* L)
{
	int a = lua_tonumber(L,);
	int b = lua_tonumber(L,);;
	int sum = a + b;
	lua_pushnumber(L, sum);
	return;
}
 
int main()
{
	lua_State* L = luaL_newstate();
	luaL_openlibs(L);
 
	lua_register(L, "CAdd", CAdd);
 
	int stat = luaL_loadfile(L, "Test.lua") | lua_pcall(L,, 0, 0);
	if (stat)
	{
		cout << "error" << endl;
	}
	else
	{
		cout << "succ" << endl;
	}
 
	lua_close(L);
 
	return;
}

lua

 
local x = CAdd(, 2)
print("x = " .. tostring(x))

运行结果：

考虑上述C++代码luaL_loadfile去加载并调用lua，lua又调用了C++注册到lua虚拟机里的CAdd函数并正确打印了返回值，结果如图所示。到底发生了什么？

C++调用lua

C++调用lua时，是对lua代码进行编译生成字节码，在运行时对字节码使用C的语法解释运行。

对luaL_loadfile调试，跟到f_parser：

 
static void f_parser (lua_State *L, void *ud) {
  LClosure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = zgetc(p->z);  /* read first character */
  if (c == LUA_SIGNATURE[]) {
    checkmode(L, p->mode, "binary");
    cl = luaU_undump(L, p->z, p->name);
  }
  else {
    checkmode(L, p->mode, "text");
    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
  }
  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
  luaF_initupvals(L, cl);
}

简单来说，parser根据输入进行词法，语法分析进行编码生成闭包，然后推入栈中等待调用。来看几个用到的数据结构。

LClosure

 
typedef struct LClosure {
  ClosureHeader;
  struct Proto *p;
  UpVal *upvals[];  //被捕获的外局部变量
} LClosure;

这是lua的闭包，此外还有CClosure是c的闭包，下面lua调用C++会提到，它们被Closure联合体包裹。

Proto

 
typedef struct Proto {
  CommonHeader;
  lu_byte numparams;  /* number of fixed parameters */
  lu_byte is_vararg;
  lu_byte maxstacksize;  /* number of registers needed by this function */
  int sizeupvalues;  /* size of 'upvalues' */
  int sizek;  /* size of 'k' */
  int sizecode;
  int sizelineinfo;
  int sizep;  /* size of 'p' */
  int sizelocvars;
  int linedefined;  /* debug information  */
  int lastlinedefined;  /* debug information  */
  TValue *k;  /* constants used by the function */
  Instruction *code;  //codes
  struct Proto **p;  /* functions defined inside the function */
  int *lineinfo;  /* map from opcodes to source lines (debug information) */
  LocVar *locvars;  /* information about local variables (debug information) */
  Upvaldesc *upvalues;  /* upvalue information */
  struct LClosure *cache;  /* last-created closure with this prototype */
  TString  *source;  /* used for debug information */
  GCObject *gclist;
} Proto;

Instruction *code;注意这个变量，这个变量就是指向我们编译后生成字节码数组的指针。

FuncState

 
typedef struct FuncState {
  Proto *f;  /* current function header */
  struct FuncState *prev;  /* enclosing function */
  struct LexState *ls;  /* lexical state */
  struct BlockCnt *bl;  /* chain of current blocks */
  int pc;  /* next position to code (equivalent to 'ncode') */
  int lasttarget;   /* 'label' of last 'jump label' */
  int jpc;  /* list of pending jumps to 'pc' */
  int nk;  /* number of elements in 'k' */
  int np;  /* number of elements in 'p' */
  int firstlocal;  /* index of first local var (in Dyndata array) */
  short nlocvars;  /* number of elements in 'f->locvars' */
  lu_byte nactvar;  /* number of active local variables */
  lu_byte nups;  /* number of upvalues */
  lu_byte freereg;  /* first free register */
} FuncState;

FuncState互相是嵌套的，外部FuncState保存了内部的部分信息，最外部的FuncState的f成员保存了编译的所有字节码，并传递给闭包LClosure。

编译lua流程

以加载lua脚本为例。

f_parser调用luaY_parser分析，并初始化Upvalues（外局部变量）。
luaY_parser 使用LexState包裹FuncState调用luaX_next进行进一步分析，其结果保存到Proto结构的code数组中，传递给LClosure并推入栈中。
luaX_next循环分析，依据词法，语法规则调用luaK_code生成字节码。
部分代码：

 
static void statement (LexState *ls) {
  int line = ls->linenumber;  /* may be needed for error messages */
  enterlevel(ls);
  switch (ls->t.token) {
    case ';': {  /* stat -> ';' (empty statement) */
      luaX_next(ls);  /* skip ';' */
      break;
    }
    case TK_IF: {  /* stat -> ifstat */
      ifstat(ls, line);
      break;
    }
    //.....................
 }
}

运行

编译代码后，便可对闭包进行解析运行了。调试代码上述 lua_pcall(L, 0, 0, 0) 代码，跟到luaD_call：

 
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 */
  L->nCcalls--;
}
}

首先调用luaD_precall进行预备工作，lua_state扩展base_ci(CallInfo类型)数组创建一个新元素保存括虚拟机的指令指针（lua_state->savedpc）在内的调用堆栈的状态以便调用结束后恢复调用堆栈，并把指令指针指向该闭包的指令数组（Closure->p->codes）。

然后调用luaV_execute循环取出指令运行。

luaV_execute解释执行部分代码:

 
void luaV_execute (lua_State *L) {
  CallInfo *ci = L->ci;
  LClosure *cl;
  TValue *k;
  StkId base;
  ci->callstatus |= CIST_FRESH;  /* fresh invocation of 'luaV_execute" */
 newframe:  /* reentry point when frame changes (call/return) */
  lua_assert(ci == L->ci);
  cl = clLvalue(ci->func);  /* local reference to function's closure */
  k = cl->p->k;  /* local reference to function's constant table */
  base = ci->u.l.base;  /* local copy of function's base */
  /* main loop of interpreter */
  for (;;) {
    Instruction i;
    StkId ra;
    vmfetch();
    vmdispatch (GET_OPCODE(i)) {
      vmcase(OP_MOVE) {
        setobjss(L, ra, RB(i));
        vmbreak;
      }
   	//............................
  }
}

CallInfo

函数执行时，lua_state通过CallInfo 数据结构了解函数的状态信息，并通过CallInfo组base_ci的上下生长来维护调用堆栈。

 
typedef struct CallInfo {
  StkId func;  /* function index in the stack */
  StkId	top;  /* top for this function */
  struct CallInfo *previous, *next;  /* dynamic call link */
  union {
    struct {  /* only for Lua functions */
      StkId base;  /* base for this function */
      const Instruction *savedpc;
    } l;
    struct {  /* only for C functions */
      lua_KFunction k;  /* continuation in case of yields */
      ptrdiff_t old_errfunc;
      lua_KContext ctx;  /* context info. in case of yields */
    } c;
  } u;
  ptrdiff_t extra;
  short nresults;  /* expected number of results from this function */
  unsigned short callstatus;
} CallInfo;

lua调用C++

lua调用C++，是上述C++调用lua时即c的语法解释运行lua代码生成的字节码的一种情况，即取出lua状态机全局表中的CClosure中的函数指针运行。

来看下向lua状态机注册C++函数lua_register

 
#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f),)
#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
 
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
  lua_lock(L);
  if (n ==) {
    setfvalue(sv(L->top), fn);
    api_incr_top(L);
  }
  else {
    CClosure *cl;
    api_checknelems(L, n);
    api_check(L, n <= MAXUPVAL, "upvalue index too large");
    cl = luaF_newCclosure(L, n);
    cl->f = fn;
    L->top -= n;
    while (n--) {
      setobjn(L, &cl->upvalue[n], s2v(L->top + n));
      /* does not need barrier because closure is white */
    }
    setclCvalue(L, sv(L->top), cl);
    api_incr_top(L);
    luaC_checkGC(L);
  }
  lua_unlock(L);
}

可以看到这里最终创建了一个CCloseure,包裹住lua_CFunction类型的函数指针并推入栈顶和放入全局表中。

 
typedef int (*lua_CFunction) (lua_State *L);
 
typedef struct CClosure {
  ClosureHeader;
  lua_CFunction f;
  TValue upvalue[];  /* list of upvalues */
} CClosure;

可以看到CClosure包含了一个lua_CFunction类型的函数指针和upvalue的链表

解释运行调用语义

循环解释字节码语义的关于调用的部分

 
void luaV_execute (lua_State *L, CallInfo *ci) {
//...
vmcase(OP_CALL) {
        int b = GETARG_B(i);
        int nresults = GETARG_C(i) -;
        if (b !=)  /* fixed number of arguments? */
          L->top = ra + b;  /* top signals number of arguments */
        /* else previous instruction set top */
        ProtectNT(luaD_call(L, ra, nresults));
        vmbreak;
      }
//...
}

可以看到调用语义的解释调用了luaD_call

 
void luaD_call (lua_State *L, StkId func, int nresults) {
  lua_CFunction f;
   retry:
  switch (ttypetag(sv(func))) {
    case LUA_VCCL:  /* C closure */
      f = clCvalue(sv(func))->f;
      goto Cfunc;
    case LUA_VLCF:  /* light C function */
      f = fvalue(sv(func));
     Cfunc: {
      int n;  /* number of returns */
      CallInfo *ci = next_ci(L);
      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
      ci->nresults = nresults;
      ci->callstatus = CIST_C;
      ci->top = L->top + LUA_MINSTACK;
      ci->func = func;
      L->ci = ci;
      lua_assert(ci->top <= L->stack_last);
      if (L->hookmask & LUA_MASKCALL) {
        int narg = cast_int(L->top - func) -;
        luaD_hook(L, LUA_HOOKCALL, -, 1, narg);
      }
      lua_unlock(L);
      n = (*f)(L);  /* do the actual call */
      lua_lock(L);
      api_checknelems(L, n);
      luaD_poscall(L, ci, n);
      break;
    }
//...

可以看到这里取到了上述Closure中的函数指针并进行调用。

	#include "Inc/lua.h"
	#include "Inc/lauxlib.h"
	#include "Inc/lualib.h"
	#include "Inc/lobject.h"
	}

	using std::cout;
	using std::endl;

	int CAdd(lua_State* L)
	{
	int a = lua_tonumber(L,);
	int b = lua_tonumber(L,);;
	int sum = a + b;
	lua_pushnumber(L, sum);
	return;
	}

	int main()
	{
	lua_State* L = luaL_newstate();
	luaL_openlibs(L);

	lua_register(L, "CAdd", CAdd);

	int stat = luaL_loadfile(L, "Test.lua") \| lua_pcall(L,, 0, 0);
	if (stat)
	{
	cout << "error" << endl;
	}
	else
	{
	cout << "succ" << endl;
	}

	lua_close(L);

	return;
	}

	static void f_parser (lua_State L, void ud) {
	LClosure *cl;
	struct SParser p = cast(struct SParser , ud);
	int c = zgetc(p->z); /* read first character */
	if (c == LUA_SIGNATURE[]) {
	checkmode(L, p->mode, "binary");
	cl = luaU_undump(L, p->z, p->name);
	}
	else {
	checkmode(L, p->mode, "text");
	cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
	}
	lua_assert(cl->nupvalues == cl->p->sizeupvalues);
	luaF_initupvals(L, cl);
	}

	typedef struct LClosure {
	ClosureHeader;
	struct Proto *p;
	UpVal *upvals[]; //被捕获的外局部变量
	} LClosure;

	typedef struct Proto {
	CommonHeader;
	lu_byte numparams; /* number of fixed parameters */
	lu_byte is_vararg;
	lu_byte maxstacksize; /* number of registers needed by this function */
	int sizeupvalues; /* size of 'upvalues' */
	int sizek; /* size of 'k' */
	int sizecode;
	int sizelineinfo;
	int sizep; /* size of 'p' */
	int sizelocvars;
	int linedefined; /* debug information */
	int lastlinedefined; /* debug information */
	TValue k; / constants used by the function */
	Instruction *code; //codes
	struct Proto *p; / functions defined inside the function */
	int lineinfo; / map from opcodes to source lines (debug information) */
	LocVar locvars; / information about local variables (debug information) */
	Upvaldesc upvalues; / upvalue information */
	struct LClosure cache; / last-created closure with this prototype */
	TString source; / used for debug information */
	GCObject *gclist;
	} Proto;

	typedef struct FuncState {
	Proto f; / current function header */
	struct FuncState prev; / enclosing function */
	struct LexState ls; / lexical state */
	struct BlockCnt bl; / chain of current blocks */
	int pc; /* next position to code (equivalent to 'ncode') */
	int lasttarget; /* 'label' of last 'jump label' */
	int jpc; /* list of pending jumps to 'pc' */
	int nk; /* number of elements in 'k' */
	int np; /* number of elements in 'p' */
	int firstlocal; /* index of first local var (in Dyndata array) */
	short nlocvars; /* number of elements in 'f->locvars' */
	lu_byte nactvar; /* number of active local variables */
	lu_byte nups; /* number of upvalues */
	lu_byte freereg; /* first free register */
	} FuncState;

	static void statement (LexState *ls) {
	int line = ls->linenumber; /* may be needed for error messages */
	enterlevel(ls);
	switch (ls->t.token) {
	case ';': { /* stat -> ';' (empty statement) */
	luaX_next(ls); /* skip ';' */
	break;
	}
	case TK_IF: { /* stat -> ifstat */
	ifstat(ls, line);
	break;
	}
	//.....................
	}
	}

	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 */
	L->nCcalls--;
	}
	}

	void luaV_execute (lua_State *L) {
	CallInfo *ci = L->ci;
	LClosure *cl;
	TValue *k;
	StkId base;
	ci->callstatus \|= CIST_FRESH; /* fresh invocation of 'luaV_execute" */
	newframe: /* reentry point when frame changes (call/return) */
	lua_assert(ci == L->ci);
	cl = clLvalue(ci->func); /* local reference to function's closure */
	k = cl->p->k; /* local reference to function's constant table */
	base = ci->u.l.base; /* local copy of function's base */
	/* main loop of interpreter */
	for (;;) {
	Instruction i;
	StkId ra;
	vmfetch();
	vmdispatch (GET_OPCODE(i)) {
	vmcase(OP_MOVE) {
	setobjss(L, ra, RB(i));
	vmbreak;
	}
	//............................
	}
	}

	typedef struct CallInfo {
	StkId func; /* function index in the stack */
	StkId top; /* top for this function */
	struct CallInfo previous, next; /* dynamic call link */
	union {
	struct { /* only for Lua functions */
	StkId base; /* base for this function */
	const Instruction *savedpc;
	} l;
	struct { /* only for C functions */
	lua_KFunction k; /* continuation in case of yields */
	ptrdiff_t old_errfunc;
	lua_KContext ctx; /* context info. in case of yields */
	} c;
	} u;
	ptrdiff_t extra;
	short nresults; /* expected number of results from this function */
	unsigned short callstatus;
	} CallInfo;

	#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f),)
	#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))

	LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
	lua_lock(L);
	if (n ==) {
	setfvalue(sv(L->top), fn);
	api_incr_top(L);
	}
	else {
	CClosure *cl;
	api_checknelems(L, n);
	api_check(L, n <= MAXUPVAL, "upvalue index too large");
	cl = luaF_newCclosure(L, n);
	cl->f = fn;
	L->top -= n;
	while (n--) {
	setobjn(L, &cl->upvalue[n], s2v(L->top + n));
	/* does not need barrier because closure is white */
	}
	setclCvalue(L, sv(L->top), cl);
	api_incr_top(L);
	luaC_checkGC(L);
	}
	lua_unlock(L);
	}

	typedef int (lua_CFunction) (lua_State L);

	typedef struct CClosure {
	ClosureHeader;
	lua_CFunction f;
	TValue upvalue[]; /* list of upvalues */
	} CClosure;

	void luaV_execute (lua_State L, CallInfo ci) {
	//...
	vmcase(OP_CALL) {
	int b = GETARG_B(i);
	int nresults = GETARG_C(i) -;
	if (b !=) /* fixed number of arguments? */
	L->top = ra + b; /* top signals number of arguments */
	/* else previous instruction set top */
	ProtectNT(luaD_call(L, ra, nresults));
	vmbreak;
	}
	//...
	}

	void luaD_call (lua_State *L, StkId func, int nresults) {
	lua_CFunction f;
	retry:
	switch (ttypetag(sv(func))) {
	case LUA_VCCL: /* C closure */
	f = clCvalue(sv(func))->f;
	goto Cfunc;
	case LUA_VLCF: /* light C function */
	f = fvalue(sv(func));
	Cfunc: {
	int n; /* number of returns */
	CallInfo *ci = next_ci(L);
	checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
	ci->nresults = nresults;
	ci->callstatus = CIST_C;
	ci->top = L->top + LUA_MINSTACK;
	ci->func = func;
	L->ci = ci;
	lua_assert(ci->top <= L->stack_last);
	if (L->hookmask & LUA_MASKCALL) {
	int narg = cast_int(L->top - func) -;
	luaD_hook(L, LUA_HOOKCALL, -, 1, narg);
	}
	lua_unlock(L);
	n = (f)(L); / do the actual call */
	lua_lock(L);
	api_checknelems(L, n);
	luaD_poscall(L, ci, n);
	break;
	}
	//...

C++实现与Lua相互调用的示例详解

目录

概述

示例

C++调用lua

编译lua流程

运行

lua调用C++

解释运行调用语义