lua源码分析：字符串
字符串类型
typedef struct TString {
CommonHeader;
lu_byte extra; 短字符串保留字
lu_byte shrlen; 短字符串长度
unsigned int hash; 字符串hash值
union {
size_t lnglen; 长字符串长度
struct TString *hnext; 指向下一个字符串
} u;
} TString;
由定义可知，TString区分长字符串和端字符串。接下来我们看TString相关函数
在学习相关接口实现之前，我们还需要了解一个重要的数据结构：global_State，
它是一个全局对象，其中的两个成员和TString接口密切相关：
TString *strcache[STRCACHE_N][STRCACHE_M]; 保存TString接口字符串缓存
stringtable strt; 是TString的hash表
Stringtable定义
typedef struct stringtable {
TString **hash;
int nuse; /* number of elements */
int size;
} stringtable;
我们主要关注以下三个创建TString的接口
LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
创建字符串
TString *luaS_new (lua_State *L, const char *str) {
unsigned int i = point2uint(str) % STRCACHE_N;
int j;
TString **p = G(L)->strcache[i];
for (j = 0; j < STRCACHE_M; j++) {
if (strcmp(str, getstr(p[j])) == 0)
return p[j];
}
/* normal route */
for (j = STRCACHE_M - 1; j > 0; j--)
p[j] = p[j - 1];
p[0] = luaS_newlstr(L, str, strlen(str));
return p[0];
}
luaS_new实现逻辑：
先在global_State的缓存strcache数组中查找是否存在相同字符串，存在则直接返回。不存在，则调用luaS_newlstr新建一个字符串，存到strcache缓存里。
创建新字符串
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
if (l <= LUAI_MAXSHORTLEN)
return internshrstr(L, str, l);
else {
TString *ts;
if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
luaM_toobig(L);
ts = luaS_createlngstrobj(L, l);
memcpy(getstr(ts), str, l * sizeof(char));
return ts;
}
}
luaS_newlstr逻辑：
这个接口很简单，根据str长度，判断是要创建短的字符串还是长字符串。长度小于40的是端字符串。
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
TString *ts;
global_State *g = G(L);
unsigned int h = luaS_hash(str, l, g->seed);
TString **list = &g->strt.hash[lmod(h, g->strt.size)];
lua_assert(str != NULL);
for (ts = *list; ts != NULL; ts = ts->u.hnext) {
if (l == ts->shrlen &&
(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
/* found! */
if (isdead(g, ts))
changewhite(ts);
return ts;
}
}
if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
luaS_resize(L, g->strt.size * 2);
list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */
}
ts = createstrobj(L, l, LUA_TSHRSTR, h);
memcpy(getstr(ts), str, l * sizeof(char));
ts->shrlen = cast_byte(l);
ts->u.hnext = *list;
*list = ts;
g->strt.nuse++;
return ts;
}
Internshrstr逻辑：改函数创建短字符串功能，首先在hash表查找是否存在字符串。存在则直接返回。不存在，创建新的字符串对象。存到hash表，同事元素个数nuse加1。所以也只有短字符串才存在hash表。
static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
TString *ts;
GCObject *o;
size_t totalsize;
totalsize = sizelstring(l);
o = luaC_newobj(L, tag, totalsize);
ts = gco2ts(o);
ts->hash = h;
ts->extra = 0;
getstr(ts)[l] = '\0';
return ts;
}
Createstrobj逻辑：创建TString字符串对象。
TString *luaS_createlngstrobj (lua_State *L, size_t l) {
TString *ts = createstrobj(L, l, LUA_TLNGSTR, G(L)->seed);
ts->u.lnglen = l;
return ts;
}
luaS_createlngstrobj逻辑：创建TString长字符串。
总体概述：
global_State的strt保存了lua系统中所有的短字符串。当需要新建字符串时，先在strcache厍中查找，存在则直接返回。如果不存在，且长度小于40，则在strt的hash表中查找，存在相同字符串则直接返回。不存在才创建新的TString对象，并把新建的字符串对象保存到strcache缓存中。Strt表中存储的对象个数大于等于strt大小时，需要把哈希表扩大为原来的两倍，这就是luaS_resize实现的功能。
void luaS_resize (lua_State *L, int newsize) {
int i;
stringtable *tb = &G(L)->strt;
if (newsize > tb->size) { /* grow table if needed */
luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
for (i = tb->size; i < newsize; i++)
tb->hash[i] = NULL;
}
for (i = 0; i < tb->size; i++) { /* rehash */
TString *p = tb->hash[i];
tb->hash[i] = NULL;
while (p) { /* for each node in the list */
TString *hnext = p->u.hnext; /* save next */
unsigned int h = lmod(p->hash, newsize); /* new position */
p->u.hnext = tb->hash[h]; /* chain it */
tb->hash[h] = p;
p = hnext;
}
}
if (newsize < tb->size) { /* shrink table if needed */
/* vanishing slice should be empty */
lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
}
tb->size = newsize;
}
luaS_resize逻辑：该函数可以扩大或缩小hash表。扩大hash表时，则需要重新计算原有对象的hash值，调整原有元素的位置。