lua中赋值类型代码详解

我们来看看lua vm在解析下面源码并生成bytecode时的整个过程:

 foo = "bar"
 local a, b = "a", "b"
 foo = a

首先我们先使用chunkyspy这个工具来看看vm最终会具体生成什么样的vm instructions

在这里，开头为[数字]的行是vm真正生成的字节码，我们看到一共生成了六行字节码。首先loadk将常量表中下标为1的常量即"bar"赋给寄存器0；然后setglobal将寄存器0的内容赋给全局变量表中下标为0的全局变量即foo；loadk再将"a"和"b"分别赋值给了寄存器0、1，在这里寄存器0和1分别表示当前函数的local变量即变量a和b；最后setglobal将变量a的值赋给了全局变量foo；最后一个return01是vm在每一个chunk最后都会生成了，并没有什么用。现在应该比较清除的了解了lua vm生成的字节码的含义了，接下来我们看看vm是怎样且为什么生成这些个字节码的。

当我们用lual_dofile函数执行这个lua脚本源码时会有两个阶段，第一个是将脚本加载进内存，分词解析并生成字节码并将其整个包裹为main chunk放于lua stack栈顶，第二是调用lua_pcall执行这个chunk，这里我们只会分析第一个过程。

前面几篇文章说了，当dofile时会跑到一个叫做luay_parser的函数中，

proto *luay_parser (lua_state *l, zio *z, mbuffer *buff, const char *name) {
 struct lexstate lexstate;
 struct funcstate funcstate;
 -- ... ...
 funcstate.f->is_vararg = vararg_isvararg; /* main func. is always vararg */
 luax_next(&lexstate); /* read first token */
 chunk(&lexstate);
 -- ... ...
 return funcstate.f;
}

函数luay_parser前面两行定义了lexstate和funcstate结构体变量，其中lexstate不仅用于保存当前的词法分析状态信息，而且也保存了整个编译系统的全局状态，funcstate结构体来保存当前函数编译的状态数据。在lua源码中都会有一个全局的函数执行体，即为main func，在开始解析的时候当前的函数必然是main func函数，此时第三行的funcstate表示了这个函数的状态，由于lua规定这个函数必然会接收不定参数因此第五行将is_vararg标识设为vararg_isvararg。接着第六行luax_next解析文件流分离出第一个token，将其保存在lexstate的t成员中，此时t为“foo”全局变量。接着调用了chunk函数，这里开始了递归下降解析的全部过程：

static void chunk (lexstate *ls) {
 /* chunk -> { stat [`;'] } */
 int islast = 0;
 enterlevel(ls);
 while (!islast && !block_follow(ls->t.token)) {
  islast = statement(ls);//递归下降点
  testnext(ls, ';');
  lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
        ls->fs->freereg >= ls->fs->nactvar);
  ls->fs->freereg = ls->fs->nactvar; /* free registers */
 }
 leavelevel(ls);
}

lua是有作用域层次概念的，因此当进入一个层次时会调用enterlevel函数，离开当前层次则会调用leavelevel函数。首先进入while循环，当前token为“foo”，这既不是终结标志也不是一个block开始的词素，因此会进入statement函数，statement函数主体是一个长长的switch...case...代码结构，根据第一个token进入不同的调用解析分支。在我们这个例子中会进入default分支：

static int statement (lexstate *ls) {
 -- ... ...
 switch (ls->t.token) {
  case tk_if: { /* stat -> ifstat */
   ifstat(ls, line);
   return 0;
  }
  case tk_while: { /* stat -> whilestat */
   whilestat(ls, line);
   return 0;
  }
  -- ... ...
  default: {
   exprstat(ls);
   return 0; /* to avoid warnings */
  }
 }
}

进入exprstate函数：

static void exprstat (lexstate *ls) {
 /* stat -> func | assignment */
 funcstate *fs = ls->fs;
 struct lhs_assign v;
 primaryexp(ls, &v.v);
 if (v.v.k == vcall) /* stat -> func */
  setarg_c(getcode(fs, &v.v), 1); /* call statement uses no results */
 else { /* stat -> assignment */
  v.prev = null;
  assignment(ls, &v, 1);
 }
}

第四行的lhs_assign结构体是为了处理多变量赋值的情况的，例如a,b,c = ...。在lhs_assign中成员v类型为expdesc描述了等号左边的变量，详情可见上篇文章里对expdesc的介绍。接下来进入primaryexp，来获取并填充“foo”变量的expdesc信息，这会接着进入prefixexp函数中

 static void prefixexp (lexstate *ls, expdesc *v) {
  /* prefixexp -> name | '(' expr ')' */
  switch (ls->t.token) {
   case '(': {
    int line = ls->linenumber;
    luax_next(ls);
    expr(ls, v);
    check_match(ls, ')', '(', line);
    luak_dischargevars(ls->fs, v);
    return;
   }
   case tk_name: {
    singlevar(ls, v);
    return;
   }
   default: {
    luax_syntaxerror(ls, "unexpected symbol");
    return;
   }
  }
 }

由于当前token是“foo”，因此进入tk_name分支，调用singlevar。

static void singlevar (lexstate *ls, expdesc *var) {
 tstring *varname = str_checkname(ls);
 funcstate *fs = ls->fs;
 if (singlevaraux(fs, varname, var, 1) == vglobal)
  var->u.s.info = luak_stringk(fs, varname); /* info points to global name */
}
static int singlevaraux (funcstate *fs, tstring *n, expdesc *var, int base) {
 if (fs == null) { /* no more levels? */
  init_exp(var, vglobal, no_reg); /* default is global variable */
  return vglobal;
 }
 else {
  int v = searchvar(fs, n); /* look up at current level */
  if (v >= 0) {
   init_exp(var, vlocal, v);
   if (!base)
    markupval(fs, v); /* local will be used as an upval */
   return vlocal;
  }
  else { /* not found at current level; try upper one */
   if (singlevaraux(fs->prev, n, var, 0) == vglobal)
    return vglobal;
   var->u.s.info = indexupvalue(fs, n, var); /* else was local or upval */
   var->k = vupval; /* upvalue in this level */
   return vupval;
  }
 }

在singlevaraux函数中会判断变量是local、upvalue还是global的。如果fs为null了则说明变量为全局的，否则进入searchvar在当前的函数局部变量数组中查找，否则根据fs的prev成员取得其父函数的funcstate并传入singlevaraux中递归查找，如果前面的都没满足则变量为upvlaue。此例中进入第21行中，由于fs已经指向了main func因此其prev为null，“foo”判定为global并返回到exprstate函数中。在取得了“foo”的信息后，因为“foo”不是函数调用，因此接着进入assignment函数中

primaryexp(ls, &v.v);
 if (v.v.k == vcall) /* stat -> func */
  setarg_c(getcode(fs, &v.v), 1); /* call statement uses no results */
 else { /* stat -> assignment */
  v.prev = null;
  assignment(ls, &v, 1);
 }

在assignment函数中首先判断下一个token是否为“,"，此例中不是则说明是单变量的赋值，接着check下一个token为”=“，成立，接着调用explist1判断等号右边有几个值，此例为1个，然后会判断左边的变量数是否等于右边的值数，不等于则进入adjust_assign函数进行调整，此例是相等的因此依次进入luak_setoneret和luak_storevar函数。在luak_storevar中首先进入int e = luak_exp2anyreg(fs, ex);函数luak_exp2anyreg的k代表了此函数是字节码相关的函数，ex为值”bar“，这个函数又调用了discharge2reg，根据ex的类型来生成不同的字节码：

static void discharge2reg (funcstate *fs, expdesc *e, int reg) {
 luak_dischargevars(fs, e);
 switch (e->k) {
  case vnil: {
   luak_nil(fs, reg, 1);
   break;
  }
  case vfalse: case vtrue: {
   luak_codeabc(fs, op_loadbool, reg, e->k == vtrue, 0);
   break;
  }
  case vk: {
   luak_codeabx(fs, op_loadk, reg, e->u.s.info);
   break;
  }
//... ...
}

由于”bar“是常量因此调用luak_codeabx函数生成loadk字节码。reg为保存载入的常量值的寄存器号，e->u.s.info根据不同类型值代表不同含义，根据注释我们知道此时info为常量数组的下标。

typedef enum {
 //... ...
 vk,    /* info = index of constant in `k' */
 vknum,  /* nval = numerical value */
 vlocal,  /* info = local register */
 vglobal,  /* info = index of table; aux = index of global name in `k' */
 //... ...
} expkind;

生成了loadk后返回到上面的函数中接着进入luak_codeabx(fs, op_setglobal, e, var->u.s.info);其中e为luak_exp2anyreg的返回值表示常量保存在的寄存器标号，info根据注释当为global类型时表示global table的相应下标，因此luak_codeabx函数将生成setglobal字节码，将刚刚用loadk将常量加载到寄存器中的值保存到global table相应的位置上。因此foo = "bar"语句就完整的生成了相应的字节码了。

接下来将生成local a,b = "a","b"语句的字节码了。过程大致相同，不同的是a，b是local变量且这个赋值语句是多变量赋值语句，因此前面的函数会用lhs_assign链表将a，b变量连接起来。如图所示：

以上所述就是本文都全部内容了，希望大家能够喜欢。