前言

接触lua近4年了，一直断断续续读相关源码，这次计划把lua源码整体分析一遍，基于最新版本(Lua 5.3.5), 完成如下文章（顺序可能不一致）：

  • 基本数据类型
  • string/table 剖析
  • luavm 分析
  • lexer/ast/gencode 词法分析/语法树/生成字节码
  • lua周边支持：debug/continue等

lua源码简介

  • 可以从lua官方网站下载最新源码：源码下载
  • 推荐直接用 vscode+wsl 阅读代码，方案参考，然后可以配置Task/Debug， 很方便地即可实现断点，code定位等常用功能， 注意修改一下gcc编译优化等级即可

Lua数据类型概括

lua数据类型定义在 lobject.h 中, 暴露出来的类型一共有9中：nil/bool/lightud/number/string/table/func/ud/thread, 定义：

#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

如此看，似乎4个bit就能完全满足类型定义了，但是lua在一些数据类型实现上还有进一步细分，如

  • LUA_TNUMBER 细分：LUA_TNUMFLT/LUA_TNUMINT (float64/int64)
  • LUA_TSTRING 细分：LUA_TSHRSTR/LUA_TLNGSTR
  • LUA_TFUNCTION 细分：LUA_TLCL/LUA_TLCF/LUA_TCCL

lua从设计上只想暴露出9中数据类型，但是实现上必须更加精巧地去考虑，那么如何用一个字节去定义9种基础类型以及部分细分类型：

  • 0 - 3bit：定义9种基础数据类型，一共可以定义15种目前用了9种
  • 4 - 6bit: 定义细分类型
#define LUA_TLCL	(LUA_TFUNCTION | (0 << 4))  /* Lua closure */
#define LUA_TLCF	(LUA_TFUNCTION | (1 << 4))  /* light C function */
#define LUA_TCCL	(LUA_TFUNCTION | (2 << 4))  /* C closure */

/* Variant tags for strings /

#define LUA_TSHRSTR	(LUA_TSTRING | (0 << 4))  / short strings /

#define LUA_TLNGSTR	(LUA_TSTRING | (1 << 4))  / long strings */


/* Variant tags for numbers /

#define LUA_TNUMFLT	(LUA_TNUMBER | (0 << 4))  / float numbers /

#define LUA_TNUMINT	(LUA_TNUMBER | (1 << 4))  / integer numbers */

那么为什么不能这么定义呢

#define LUA_TNUMFLT		9
#define LUA_TNUMINT     10
....

如果真的这样定义也不是一定就不行，但是会有一个小问题，当我们判断某个数据类型是不是 LUA_TNUMBER 时就变得有点麻烦，可能就需要if type == LUA_TNUMFLT or type == LUA_TNUMINT {do something}, 但是用bit去定义就可以 if type & LUA_TNUMBER { do something}

Lua数据类型结构体定义

  • lua 是一种弱类型脚本语言，所以在实现时期望用一个统一的结构对象去实现所有类型，类比到高级语言种如：C# 可以用object对象去实现，golang可以用interface{}，java可以用Object等等，不考虑值类型装箱问题的话，的确可以这么做的。 但是放到c语言中，假设我们尝试用void*去处理，一则值类型也必须用指针处理，再者此时就失去原类型的定义，如任意 void* ptr并无法知道ptr具体是什么类型

  • 可以用 struct 去实现吗？ 自然也不太好，struct会带来内存浪费问题，比如会如下定义 : 
    typedef struct LuaType {
  int64 num;
  char* str;
  Table tbl;
  char type;
  ... 
  }

    那么对于任意 LuaType 对象来说，内存都是 sizeof(LuaType) = sizeof(int64)+sizeof(char*)…., 然后需要的仅仅是某个类型+type的内存

  • Lua用了c中union去实现这种“内存共享”逻辑 union 参考

Lua 数据类型大体上分为：可被GC的对象 / 值类型，TValue 是lua中所有类型的表示, 定义：

typedef union Value {
  GCObject *gc;    /* collectable objects */
  void *p;         /* light userdata */
  int b;           /* booleans */
  lua_CFunction f; /* light C functions */
  lua_Inteluager i;   /* integer numbers */
  lua_Number n;    /* float numbers */
} Value;

#define TValuefields	Value value_; int tt_


typedef struct lua_TValue {

TValuefields;

} TValue;

其中 Value value_ 定义了数据部分，tt_ 定义了数据类型：

  • lua_Number/lua_Inteluager 分别定义为：double/long long，所以lua中number就是8字节，浮点的数的话用double，那么它的精度就是52位 （最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M）， 所以如果是一个超出52位整型转float64时可能会丢失精度

  • 所以一个lua 数据对象，在内存中占用最少 12byte = sizeof(long long) + sizeof(int)

  • tt_ 定义了具体数据类型，其中如果是 GCObject* 则tt_第7位会标记出来 #define BIT_ISCOLLECTABLE (1 << 6);#define ctb(t) ((t) | BIT_ISCOLLECTABLE)

GCObject 是所有可GC对象的定义

  • next 字段使得GCObject可以变成一个单项链表，用于GC过程中遍历以及“根对象”管理
  • tt 表示该对象类型类型
  • mark 字段用于GC过程中的 扫描标记中 white/gray/black 标记
/* Common Header for all collectable objects (in macro form, to be included in other objects) */
#define CommonHeader	GCObject *next; lu_byte tt; lu_byte marked

/* Common type has only the common header */

struct GCObject {

CommonHeader;

};

Lua 数据结构字段get/set 封装

为了更加方便地操作TValue字段，Lua定义了各种宏去判断类型/字段访问等，之所以用宏，主要考虑避免method频繁调用带来的上下文切换开销：

#define val_(o)		((o)->value_)

/* raw type tag of a TValue */

#define rttype(o)	((o)->tt_)


/* tag with no variants (bits 0-3) */

#define novariant(x)	((x) & 0x0F)


/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */

#define ttype(o)	(rttype(o) & 0x3F)


/* type tag of a TValue with no variants (bits 0-3) */

#define ttnov(o)	(novariant(rttype(o)))

值得注意的是 如果是9种基础类型，那么用：novariant(x) 去处理即可, 细分类型用 ttype(o), 正如Lua源码更高级地接口封装：

/* Macros to test type */
#define checktag(o,t)		(rttype(o) == (t))
#define checktype(o,t)		(ttnov(o) == (t))
#define ttisnumber(o)		checktype((o), LUA_TNUMBER)
#define ttisfloat(o)		checktag((o), LUA_TNUMFLT)
#define ttisinteger(o)		checktag((o), LUA_TNUMINT)
...

对于非GC类型的对象，get/set 不用转型，直接访问即可，如：

#define settt_(o,t)	((o)->tt_=(t))

#define setfltvalue(obj,x)

{ TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_TNUMFLT); }


#define chgfltvalue(obj,x)

{ TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }


#define setivalue(obj,x)

{ TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_TNUMINT); }

但是GC类型需要特殊处理一下， 因为他们本身是一种”继承“的复合类型，如string的定义：

  /*
** Header for string value; string bytes follow the end of this structure
** (aligned according to 'UTString'; see next).
*/
typedef struct TString {
  CommonHeader;
  lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
  lu_byte shrlen;  /* length for short strings */
  unsigned int hash;
  union {
    size_t lnglen;  /* length for long strings */
    struct TString *hnext;  /* linked list for hash table */
  } u;
} TString;

/*

** Ensures that address after this type is always fully aligned.

/

typedef union UTString {

L_Umaxalign dummy;  / ensures maximum alignment for strings */

TString tsv;

} UTString;

复杂的GCObject类型数据访问方式需要特使处理，TString 内存结构： TString+rawData, 其中rawData就是真正存数据的内存，所以分配过程：

static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
  TString *ts;
  GCObject *o;
  size_t totalsize;  /* total size of TString object */
  totalsize = sizelstring(l);
  o = luaC_newobj(L, tag, totalsize);
  ts = gco2ts(o);
  ts->hash = h;
  ts->extra = 0;
  getstr(ts)[l] = '