lua string源码分析总结
lua字符串内部存储分为短字符串和长字符串，可以从下面的宏看出：
#define LUA_TSTRING 4
/* Variant tags for strings */
#define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */
#define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */可以看出短字符串为4；长的是20；
TString类型定义为lobejct里：
/*
** Header for string value; string bytes follow the end of this structure
*/
typedef union TString {
L_Umaxalign dummy; /* ensures maximum alignment for strings */
struct {
CommonHeader;
lu_byte extra; /* 对于段字符串表示是否为保留字；对于长字符串用于lazy hash*/
unsigned int hash;
size_t len; /* 字符串长度【lua内string不以'\0'结尾，所以需要显式指定大小】 */
} tsv;
} TString;前面的 dummy是一个宏：
#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; }这个union就是8个字节；
TString也是个union，因此大小一定是8的倍数，这就保证了TString大小一定是8的倍数。
字符串作为经常被用到的数据类型，会在很多场景下被创建：
比如：
LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
TString *ts;
lua_lock(L);
luaC_checkGC(L);
ts = luaS_newlstr(L, s, len);
setsvalue2s(L, L->top, ts);
api_incr_top(L);
lua_unlock(L);
return getstr(ts);
}/*
** new string (with explicit length)
*/
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
if (l <= LUAI_MAXSHORTLEN) /* short string? */
return internshrstr(L, str, l);
else {
if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
luaM_toobig(L);
return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
}
}首先判断如果是短字符串，就内部化；
如果长度太大，就报错；否则 开始创建。
那首先看看如何内部化：
/*
** checks whether short string exists and reuses it or creates a new one
*/
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
GCObject *o;
global_State *g = G(L);
unsigned int h = luaS_hash(str, l, g->seed);
for (o = g->strt.hash[lmod(h, g->strt.size)];
o != NULL;
o = gch(o)->next) {
TString *ts = rawgco2ts(o);
if (h == ts->tsv.hash &&
l == ts->tsv.len &&
(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
if (isdead(G(L), o)) /* string is dead (but was not collected yet)? */
changewhite(o); /* resurrect it */
return ts;
}
}
return newshrstr(L, str, l, h); /* not found; create a new string */
}首先根据 字符内容，长度和hash种子获取hash值，然后遍历string table相应hash桶内的字符对象，并用hash值、字符内存、字符长度进行比较，如果都相等，说明已经存在此字符串，如果发现已死，就复活之（这是GC的内容，暂时跳过），然后返回，在这里实现了重用；
当然如果没找到，就要第一次分配对象：
/*
** creates a new short string, inserting it into string table
*/
static TString *newshrstr (lua_State *L, const char *str, size_t l,
unsigned int h) {
GCObject **list; /* (pointer to) list where it will be inserted */
stringtable *tb = &G(L)->strt;
TString *s;
if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
luaS_resize(L, tb->size*2); /* too crowded */
list = &tb->hash[lmod(h, tb->size)];
s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
tb->nuse++;
return s;
}当新字符串的长度超过string tabler已有string数量的时候，hash值再次计算会发生冲突，因此这时候要进行resize,就是根据新的长度重新映射hash值；
这时候才开始真正分配新string：
/*
** creates a new string object
*/
static TString *createstrobj (lua_State *L, const char *str, size_t l,
int tag, unsigned int h, GCObject **list) {
TString *ts;
size_t totalsize; /* total size of TString object */
totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
ts->tsv.len = l;
ts->tsv.hash = h;
ts->tsv.extra = 0;
memcpy(ts+1, str, l*sizeof(char));
((char *)(ts+1))[l] = '\0'; /* ending 0 */
return ts;
}
从totatlesize的计算方法可以看出TSring只是一个头，真正的内容放在TString之后；
然后再来一层 创建对象：
/*
** create a new collectable object (with given type and size) and link
** it to '*list'. 'offset' tells how many bytes to allocate before the
** object itself (used only by states).
*/
GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list,
int offset) {
global_State *g = G(L);
char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz));
GCObject *o = obj2gco(raw + offset);
if (list == NULL)
list = &g->allgc; /* standard list for collectable objects */
gch(o)->marked = luaC_white(g);
gch(o)->tt = tt;
gch(o)->next = *list;
*list = o;
return o;
}luaM_newobject会调用luaM_realloc_真正分配内存，这里具体的内存分配策略就权当是malloc分配的（暂时如此认为）。此时会把此object链接到stringtable上。还可以看出string table会更新相关域。
好吧，字符串的创建分析完了。
参考：云风《lua源码赏析》
分析的不对的地方请斧正，哈哈。