关于lua 5.1源码分析与相关有用摘要

最新推荐文章于 2019-08-28 20:59:54 发布

maijian

最新推荐文章于 2019-08-28 20:59:54 发布

阅读量934

点赞数

本文链接：https://blog.csdn.net/maijian/article/details/24028691

版权

lua 5.1 的代码在线浏览 http://www.lua.org/source/5.1/

关于lua代码的阅读顺序，来自于 http://www.reddit.com/comments/63hth/ask_reddit_which_oss_codebases_out_there_are_so/c02pxbp

global_State

一个lua虚拟机中只有一个, 它管理着lua中全局唯一的信息, 主要是以下功能

1. 内存分配策略及其参数, 在调用lua_newstate的时候配置它们. 也可以通过lua_getallocf和lua_setallocf随时获取和修改它

2. 字符串的hashtable, lua中所有的字符串都会在该hashtable中注册.

3. gc相关的信息. 内存使用统计量.

4. panic, 当无保护调用发生时, 会调用该函数, 默认是null, 可以通过lua_atpanic配置.

5. 注册表, 注意, 注册表是一个全局唯一的table.

6. 记录lua中元方法名称和基本类型的元表[注意, lua中table和userdata每个实例可以拥有自己的独特的元表--记录在table和userdata的mt字段, 其他类型是每个类型共享一个元表--就是记录在这里].

7. upvalue链表.

8. 主lua_State, 一个lua虚拟机中, 可以有多个lua_State, lua_newstate会创建出一个lua_State, 并邦定到global_state的主lua_State上.

global_State主要是管理lua虚拟机的全局环境.

lua_State

1. 要注意的是, 和nil, string, table一样, lua_State也是lua中的一种基本类型, lua中的表示是TValue {value = lua_State, tt = LUA_TTHREAD}

2. lua_State的成员和功能

a. 栈的管理, 包括管理整个栈和当前函数使用的栈的情况.

b. CallInfo的管理, 包括管理整个CallInfo数组和当前函数的CallInfo.

c. hook相关的, 包括hookmask, hookcount, hook函数等.

d. 全局表l_gt, 注意这个变量的命名, 很好的表现了它其实只是在本lua_State范围内是全局唯一的的, 和注册表不同, 注册表是lua虚拟机范围内是全局唯一的.

e. gc的一些管理和当前栈中upvalue的管理.

f. 错误处理的支持.

3. 从lua_State的成员可以看出来, lua_State最主要的功能就是函数调用以及和c的通信.

lua_State主要是管理一个lua虚拟机的执行环境, 一个lua虚拟机可以有多个执行环境.

在lua_State结构里面，stack是需要我们重点了解的，lua会把执行需要的参数，函数调用等都放到stack里面，具体可以参考

上面的图片。stack里面的所有元素都是StkId类型，而StkId则是Tvalue*的宏定义，TValue则是记录了元素的类型等重要信息，

只有两个字段 Value value 和 int tt，其中value是类型的属性，然后tt则标识类型，下面是tt可能记录的类型

   #define LUA_TNONE               (-1)
   #define LUA_TNIL                0
   #define LUA_TBOOLEAN            1
   #define LUA_TLIGHTUSERDATA      2
   #define LUA_TNUMBER             3
   #define LUA_TSTRING             4
   #define LUA_TTABLE              5
   #define LUA_TFUNCTION           6
   #define LUA_TUSERDATA           7
   #define LUA_TTHREAD             8

除了stack之外，我们还要了解 Instruction *savedpc 这个字段， Instruction 其实是一个 uint32类型，这个savedpc指向的是

虚拟机执行的二进制指令，这是一个uint32的数值，当后面分析完lua脚本开始执行lua指令的时候就是从savaedpc开始读取

指令执行的。具体在后面会详细介绍。

另外还有CallInfo的字段成员，

   CallInfo *ci; /* call info for current function */
   CallInfo *end_ci; /* points after end of ci array*/
   CallInfo *base_ci; /* array of CallInfo's */

关于CallInfo结构，如下：

   /*
   ** informations about a call
   */
   typedef struct CallInfo {
     StkId base; /* base for this function */
   StkId func; /* function index in the stack */
   StkId top; /* top for this function */
     const Instruction *savedpc;
   int nresults; /* expected number of results from this function */
   int tailcalls; /* number of tail calls lost under this entry */
   } CallInfo;

2.在lua.c的pmain函数里面，有几个函数是需要我们了解的，luaL_openlibs这个函数主要是做一些lua内部库函数的初始化工作

做完初始化的工作之后，有两种模式，假如我们是以lua脚本的方式调用lua，则执行handle_script函数，另外一种就是交互模

式的，这种就是在终端输入lua命令即时看到执行结果，这个则是执行dotty函数。因为我对lua的词法，语法分析，还有虚拟机

等比较有兴趣，所以我选择去了解handle_script。

3.在handle_script函数里面主要有2个调用，luaL_loadfile 和 docall。

luaL_loadfile主要实现的是词法分析，语法分析，生成lua虚拟机指令，docall则是执行之前生成好的lua脚本虚拟机指令。

调用关系

luaL_loadfile -> lua_load -> luaD_protectedparser -> f_parser ->

luaY_parser -> luaX_next 词法分析

-> chunk 语法分析，生成指令

下面我们先看看f_parser做了些什么

static void f_parser (lua_State *L, void *ud) {
int i;
Proto *tf;
Closure *cl;
struct SParser *p = cast(struct SParser *, ud);
int c = luaZ_lookahead(p->z);
luaC_checkGC(L);
tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
&p->buff, p->name);
cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
cl->l.p = tf;
for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */
cl->l.upvals[i] = luaF_newupval(L);

#这里很关键，这里是把luaY_parser分析完的Proto打包进Closure，然后放到lua_State的statck top里面
setclvalue(L, L->top, cl);
incr_top(L);
}

接下来我们再看看 luaY_parser

Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
struct LexState lexstate;
struct FuncState funcstate;
lexstate.buff = buff;
luaX_setinput(L, &lexstate, z, luaS_new(L, name));

#open_func函数里面，会把Table和Proto push到lua_State的stack top里面

open_func(&lexstate, &funcstate);

funcstate.f->is_vararg = VARARG_ISVARARG; /* main func. is always vararg */

#词法分析

luaX_next(&lexstate); /* read first token */

#语法分析并生成指令
chunk(&lexstate);

check(&lexstate, TK_EOS);
close_func(&lexstate);
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.f->nups == 0);
lua_assert(lexstate.fs == NULL);
return funcstate.f;
}

static void open_func (LexState *ls, FuncState *fs) {
lua_State *L = ls->L;
Proto *f = luaF_newproto(L);
fs->f = f;
fs->prev = ls->fs; /* linked list of funcstates */
fs->ls = ls;
fs->L = L;
ls->fs = fs;
fs->pc = 0;
fs->lasttarget = -1;
fs->jpc = NO_JUMP;
fs->freereg = 0;
fs->nk = 0;
fs->np = 0;
fs->nlocvars = 0;
fs->nactvar = 0;
fs->bl = NULL;
f->source = ls->source;
f->maxstacksize = 2; /* registers 0/1 are always valid */
fs->h = luaH_new(L, 0, 0);
/* anchor table of constants and prototype (to avoid being collected) */
sethvalue2s(L, L->top, fs->h); #把Table push到 lua_State的stack top
incr_top(L);
setptvalue2s(L, L->top, f); #把Proto push到 lua_State的stack top
incr_top(L);
}

下面我们再看看chunk，它会调用 statemenet做语法分析，指令生成，通常指令生成都会调用lcode.c里面的

luaK_code

static int luaK_code (FuncState *fs, Instruction i, int line) {
Proto *f = fs->f;
dischargejpc(fs); /* `pc' will change */

/* 这里就是把指令I，也就是uint32的数据添加到Proto的code数组里面去，这个code数组在docall里面会赋值

到lua_State的savedpc去执行指令的 */
/* put new instruction in code array */
luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
MAX_INT, "code size overflow");
f->code[fs->pc] = i;

/* save corresponding line information */
luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
MAX_INT, "code size overflow");
f->lineinfo[fs->pc] = line;
return fs->pc++;
}

4.现在可以开始分析docall，调用关系如下

docall -> lua_pcall -> f_call -> luaD_call -> luaD_precall

-> luaV_execute

先看 luaD_precall，它主要是把 lua_Stat的stack的内容，比如参数，函数，c调用等提取出来，并准备好等下的

虚拟机执行，比如把 lua_State->savedpc = Proto.code

接着看luaV_execute,它就负责从lua_State->savepc取出指令执行