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变量连接起来。如图所示:

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

(0)

相关推荐

  • Lua中的基本数据类型详细介绍

    基础介绍 Lua是一种动态类型的语言.在语言中没有类型定义的语法,每个值都带有其自身的类型信息.在Lua中有8中基本类型,分别是: 1.nil(空)类型 2.boolean(布尔)类型 3.number(数字)类型 4.string(字符串)类型 5.userdata(自定义类型) 6.function(函数)类型 7.thread(线程)类型 8.table(表)类型 以上是Lua中的8中基本类型,我们可以使用type函数,判断一个值得类型,type函数返回一个对应类型的字符串描述.例如: 复

  • Lua变量类型简明总结

    在上一节中说到了Lua的安装与变量,这节说说Lua变量的类型.Lua在使用中不需要预先定义变量的类型.Lua中基本的类型有:nil.boolean.number.string.userdata.function.thread.table.可以使用type函数来判断变量的类型. 1. nil nil是一个特殊的类型,用来表示该变量还没有被赋值,如果一个变量赋值为nil,可以删除这个变量. 2. boolean boolean类型的变量只有两个值:true和false.在条件表达式中非常有用的.在控

  • Lua教程(三):值与类型介绍

    Lua 是一种 动态类型语言. 这意味着变量没有类型,只有值才有类型. 语言中不存在类型定义.而所有的值本身携带它们自己的类型信息. Lua 中的所有值都是一致 (first-class) 的. 这意味着所有的值都可以被放在变量里,当作参数传递到另一个函数中,并被函数作为结果返回. Lua 中有八种基本类型: nil, boolean, number, string, function, userdata, thread, and table. Nil 类型只有一种值 nil ,它的主要用途用于

  • Lua基础教程之赋值语句、表达式、流程控制、函数学习笔记

    赋值语句 注释,单行用(--)来表示:多行用(--[[ ... ]])来标示: 定义,lua中没有定义(申明数据类型),它是通过赋值来确定其数据类型的. 赋值,是改变一个变量的值和改变表域的最基本的方法. a = "hello" .. "world" Lua可以对多个变量同时赋值,变量列表和值列表的各个元素用逗号分开,赋值语句右边的值会依次赋给左边的变量.a, b = 10, 2*x <--> a=10; b=2*x 遇到赋值语句Lua会先计算右边所有的

  • Lua数据类型介绍

    Lua 是一个功能强大.快速.轻量的可嵌入式脚本语言,由标准的 ANSI C 实现,由于拥有一组精简的强大特性,以及容易使用的 C API,这使得它可以很容易嵌入或扩展到其他语言中使用,并且有个非官方认领的中文名 -- "撸啊". 安装 Lua Lua 安装很简单,把源码下载下来后,直接 make 就行: 复制代码 代码如下: wget http://www.lua.org/ftp/lua-5.2.2.tar.gz tar -zxvf lua-5.2.2.tar.gz cd lua-5

  • lua中赋值类型代码详解

    我们来看看lua vm在解析下面源码并生成bytecode时的整个过程: foo = "bar" local a, b = "a", "b" foo = a 首先我们先使用ChunkySpy这个工具来看看vm最终会具体生成什么样的vm instructions 在这里,开头为[数字]的行是vm真正生成的字节码,我们看到一共生成了六行字节码.首先loadk将常量表中下标为1的常量即"bar"赋给寄存器0:然后setglobal将

  • Python中的asyncio代码详解

    asyncio介绍 熟悉c#的同学可能知道,在c#中可以很方便的使用 async 和 await 来实现异步编程,那么在python中应该怎么做呢,其实python也支持异步编程,一般使用 asyncio 这个库,下面介绍下什么是 asyncio : asyncio 是用来编写 并发 代码的库,使用 async/await 语法. asyncio 被用作多个提供高性能 Python 异步框架的基础,包括网络和网站服务,数据库连接库,分布式任务队列等等. asyncio 往往是构建 IO 密集型和

  • Java中可变长度参数代码详解

    到J2SE1.4为止,一直无法在Java程序里定义实参个数可变的方法--因为Java要求实参(Arguments)和形参(Parameters)的数量和类型都必须逐一匹配,而形参的数目是在定义方法时就已经固定下来了.尽管可以通过重载机制,为同一个方法提供带有不同数量的形参的版本,但是这仍然不能达到让实参数量任意变化的目的. 然而,有些方法的语义要求它们必须能接受个数可变的实参--例如著名的main方法,就需要能接受所有的命令行参数为实参,而命令行参数的数目,事先根本无法确定下来. 对于这个问题,

  • mybatis-plus  mapper中foreach循环操作代码详解(新增或修改)

    .循环添加 接口处: 分别是 void 无返回类型 :有的话是(resultType)返回类型,参数类型(parameterType) list , 如: 在mapper文件中分别对应ID,参数类型和返回类型. 循环处理,如下: <insert id="insertPack" parameterType="java.util.List"> insert into t_ev_bu_pack ( PACK_CODE, BIN, PACK_PROD_TIME,

  • ES6中的Promise代码详解

    废话不多说了,直接给大家贴代码了,具体如下所示: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title></title> </head> <body> <script> var a=0 var test=function(resolve, reject){ setTimeou

  • Spring中MVC模块代码详解

    SpringMVC的Controller用于处理用户的请求.Controller相当于Struts1里的Action,他们的实现机制.运行原理都类似 Controller是个接口,一般直接继承AbstrcatController,并实现handleRequestInternal方法.handleRequestInternal方法相当于Struts1的execute方法 import org.springframework.web.servlet.ModelAndView; import org.

  • Django中的Signal代码详解

    本文研究的主要是Django开发中的signal 的相关内容,具体如下. 前言 在web开发中, 你可能会遇到下面这种场景: 在用户完成某个操作后, 自动去执行一些后续的操作. 譬如用户完成修改密码后, 你要发送一份确认邮件. 当然可以把逻辑写在一起,但是有个问题是,触发操作一般不止一种(如用户更改了其它信息的确认邮件),这时候这个逻辑会需要写多次,所以你可能会想着DRY(Don't repeat yourself),于是你把它写到了一个函数中,每次调用.当然这是没问题的. 但是, 如果你换个思

  • Lua中的面向对象编程详解

    简单说说Lua中的面向对象 Lua中的table就是一种对象,看以下一段简单的代码: 复制代码 代码如下: local tb1 = {a = 1, b = 2} local tb2 = {a = 1, b = 2} local tb3 = tb1   if tb1 == tb2 then      print("tb1 == tb2") else      print("tb1 ~= tb2") end   tb3.a = 3 print(tb1.a) 上述代码会输

  • Lua中table的遍历详解

    当我在工作中使用lua进行开发时,发现在lua中有4种方式遍历一个table,当然,从本质上来说其实都一样,只是形式不同,这四种方式分别是: 复制代码 代码如下: for key, value in pairs(tbtest) do      XXX  end   for key, value in ipairs(tbtest) do      XXX  end   for i=1, #(tbtest) do      XXX  end   for i=1, table.maxn(tbtest)

  • Lua中的协同程序详解

    前言 协同程序与线程差不多,也就是一条执行序列,拥有自己独立的栈.局部变量和指令指针,同时又与其它协同程序共享全局变量和其它大部分东西.从概念上讲,线程与协同程序的主要区别在于,一个具有多个线程的程序可以同时运行几个线程,而协同程序却需要彼此协作的运行.就是说,一个具有多个协同程序的程序在任意时刻只能运行一个协同程序,并且正在运行的协同程序只会在其显式地要求挂起时,它的执行才会暂停. 协同程序基础 Lua将所有关于协同程序的函数放置在一个名为"coroutine"的table中.函数c

随机推荐