Lua 最初使用的是 Yacc 生成的语法分析器，后来改为手写的递归下降语法分析器（Recursive descent parser）。因为一般在语言发展的早期，语言的语法还没有稳定下来，变动可能会比较多，用工具可以快速的验证自己的想法。当语法稳定下来之后，一般都会采用手写的语法分析器。因为这样程序员是调试可控的，并且一般也能有更好的性能表现。递归下降的语法分析对编程语言的语法有要求。因 Lua 的语法比较简单，是 LL(1) 文法。所以，手工编写语法分析也就是情理之中的事了。
关于递归下降的语法分析，网上资料不少，比如维基百科：
https://en.wikipedia.org/wiki/Recursive_descent_parser
比如这篇：
http://www.cnblogs.com/Ninputer/archive/2011/06/21/2085527.html
里面都有很不错的示例。
具体内容就不贴出来了，感兴趣的同学可以自行阅读。
说到这儿，再往下说，就是具体的代码了。
对照 Lua 的 EBNF 语法（在 Lua 手册的最后面，有完整的语法表），一点点的套代码吧。
看一个经典的“hello world”程序吧。
程序的内容如下所示：
print("hello world! (using print)\n")
假设把它保存为 hello.lua 文件。
通过执行下面的命令，打印出它的字节码。
luac.exe -l hello.lua
下面是程序的输出：
main <0:@hello.lua> (4 instructions/16 bytes at 0087A0E8)
0 params, 2 stacks, 0 locals, 2 strings, 0 numbers, 0 functions, 2 lines
1 [1] GETGLOBAL 0 ; print
2 [1] PUSHSTRING 1 ; "hello world! (using print)\n"
3 [1] CALL 0 0
4 [1] END
程序输出的意思：
main 表示是顶层主程序，如果是函数定义的话，这里显示为 function
0:@hello.lua 程序从第 0 行开始，文件名为 hello.lua
后面的表示 4 条指令，共 16 个字节，位于内存 0087A0E8 处。
再下一行表示，有多少个参数，占用了多少个栈空间，局部变量个数，多少个字符串，数字，函数，及行数。
再下面就是字节码指令的具体内容（以方便阅读的形式表示出来的）。
每行的内容分别为 指令号，对应源代码的行号，指令，分号后面的为注释。
再来看看指令的具体内容：
GETGLOBAL 取得一个全局变量，由注释可以看到，取得的全局变量为 print
PUSHSTRING 字符串压栈
CALL 函数调用
END 结束
取得全局变量的时候，把取出来的全局变量放到什么地方？放到了数据栈上，就是下面字符串压栈的那个同样的栈。
在字节码运行的时候，Lua 虚拟机根据字节码指令指示，把相关的数据放到数据栈上，而后进行相应的操作。
因为虚拟机对数据栈的操作只会在栈顶进行，所以，我们说 Lua4.0 的虚拟机是栈式虚拟机。
看一看这个语法分析的函数调用流程：
从 luaY_parser 开始看。
Proto *luaY_parser (lua_State *L, ZIO *z) {
struct LexState lexstate;
struct FuncState funcstate;
luaX_setinput(L, &lexstate, z, luaS_new(L, zname(z)));
open_func(&lexstate, &funcstate);
next(&lexstate); /* read first token */
chunk(&lexstate);
//...
return funcstate.f;
}
程序上来先设置好 LexState, FuncState
调用 next 取得第一个 token，就是 print 。
进入 chunk
static void chunk (LexState *ls) {
/* chunk -> { stat [‘;‘] } */
int islast = 0;
while (!islast && !block_follow(ls->t.token)) {
islast = stat(ls);
optional(ls, ‘;‘);
//...
}
}
进入语句 stat
static int stat (LexState *ls) {
int line = ls->linenumber; /* may be needed for error messages */
switch (ls->t.token) {
// other cases
case TK_NAME: case ‘%‘: { /* stat -> namestat */
namestat(ls);
return 0;
}
// other cases
}
}
里面是个大的 switch case 。
这里触发的是 TK_NAME:
进入 namestat
static void namestat (LexState *ls) {
/* stat -> func | [‘%‘] NAME assignment */
FuncState *fs = ls->fs;
expdesc v;
var_or_func(ls, &v);
if (v.k == VEXP) { /* stat -> func */
check_condition(ls, luaK_lastisopen(fs), "syntax error"); /* an upvalue? */
luaK_setcallreturns(fs, 0); /* call statement uses no results */
}
else { /* stat -> [‘%‘] NAME assignment */
int left = assignment(ls, &v, 1);
luaK_adjuststack(fs, left); /* remove eventual garbage left on stack */
}
}
进入 var_or_func，设置表达式描述符 expdesc
static void var_or_func (LexState *ls, expdesc *v) {
/* var_or_func -> [‘%‘] NAME var_or_func_tail */
if (optional(ls, ‘%‘)) { /* upvalue? */
pushupvalue(ls, str_checkname(ls));
v->k = VEXP;
v->u.l.t = v->u.l.f = NO_JUMP;
}
else /* variable name */
singlevar(ls, str_checkname(ls), v);
var_or_func_tail(ls, v);
}
显然，这里不是 upvalue，只是一个简单的变量名。
进入 singlevar, 先取得一个 TString 的值：
static TString *str_checkname (LexState *ls) {
TString *ts;
check_condition(ls, (ls->t.token == TK_NAME), "<name> expected");
ts = ls->t.seminfo.ts;
next(ls);
return ts;
}
取得一个 TString
static void singlevar (LexState *ls, TString *n, expdesc *var) {
int level = search_local(ls, n, var);
if (level >= 1) /* neither local (0) nor global (-1)? */
luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str);
else if (level == -1) /* global? */
var->u.index = string_constant(ls->fs, n);
}
查看是否是局部变量，显然不是。这里 level 值为 -1。
取得 string 在全局字符串表中的下标：
static int string_constant (FuncState *fs, TString *s) {
Proto *f = fs->f;
int c = s->u.s.constindex;
if (c >= f->nkstr || f->kstr[c] != s) {
luaM_growvector(fs->L, f->kstr, f->nkstr, 1, TString *,
"constant table overflow", MAXARG_U);
c = f->nkstr++;
f->kstr[c] = s;
s->u.s.constindex = c; /* hint for next time */
}
return c;
}
回到 var_or_func, 进入 var_or_func_tail
static void var_or_func_tail (LexState *ls, expdesc *v) {
for (;;) {
switch (ls->t.token) {
// other cases:
case ‘(‘: case TK_STRING: case ‘{‘: { /* var_or_func_tail -> funcargs */
luaK_tostack(ls, v, 1); /* `v‘ must be on stack */
funcargs(ls, 0);
v->k = VEXP;
v->u.l.t = v->u.l.f = NO_JUMP;
break;
}
default: return; /* should be follow... */
}
}
}
因为当前的 token 为 ‘(‘，所以进入上面的 case。
进入 luaK_tostack（位于 lcode.c 文件中），生成字节码 GETGLOBAL 0
进入 funcargs，设置函数 print 的参数。
static void funcargs (LexState *ls, int slf) {
FuncState *fs = ls->fs;
int slevel = fs->stacklevel - slf - 1; /* where is func in the stack */
switch (ls->t.token) {
case ‘(‘: { /* funcargs -> ‘(‘ [ explist1 ] ‘)‘ */
int line = ls->linenumber;
int nargs = 0;
next(ls);
if (ls->t.token != ‘)‘) /* arg list not empty? */
nargs = explist1(ls);
check_match(ls, ‘)‘, ‘(‘, line);
#ifdef LUA_COMPAT_ARGRET
if (nargs > 0) /* arg list is not empty? */
luaK_setcallreturns(fs, 1); /* last call returns only 1 value */
#else
UNUSED(nargs); /* to avoid warnings */
#endif
break;
}
// other cases
}
fs->stacklevel = slevel; /* call will remove function and arguments */
luaK_code2(fs, OP_CALL, slevel, MULT_RET);
}
因为有参数，所以进入 explist1
static int explist1 (LexState *ls) {
/* explist1 -> expr { ‘,‘ expr } */
int n = 1; /* at least one expression */
expdesc v;
expr(ls, &v);
while (ls->t.token == ‘,‘) {
luaK_tostack(ls, &v, 1); /* gets only 1 value from previous expression */
next(ls); /* skip comma */
expr(ls, &v);
n++;
}
luaK_tostack(ls, &v, 0); /* keep open number of values of last expression */
return n;
}
先通过 expr 取得表达示描述信息。
进入 expr, subexpr, simpleexp
因为是一个简单的表达式，只有一个字符串 "hello world! (using print)\n",
static void simpleexp (LexState *ls, expdesc *v) {
FuncState *fs = ls->fs;
switch (ls->t.token) {
// other cases
case TK_STRING: { /* simpleexp -> STRING */
code_string(ls, ls->t.seminfo.ts); /* must use `seminfo‘ before `next‘ */
next(ls);
break;
}
// other codes
code_string 设置字节码，PUSHSTRING 1
回到 funcargs。设置函数调用字节码：
luaK_code2(fs, OP_CALL, slevel, MULT_RET);
回到 namestat，设置返回字节码：END
回到 chunk，luaY_parser 语法分析结束。
语法分析过程再跟踪下去基本就是个体力活了，不再举例子了。
对照着 EBNF 及生成的字节码，一步步的跟踪就是了。
其它的语法分析的理论，参见编译原理。
或者是看开头部分的那些简要的描述，也可以了解了大概。
----------------------------------------
到目前为止的问题：
> TString 数据结构和 luaS_new
> 函数原型优化 luaU_optchunk
> 打印函数原型 luaU_printchunk
> dump 函数原型 luaU_dumpchunk
----------------------------------------