lua.5.2.3源码阅读(04)：Table结构基本操作

 1 // TKey结构是一个链表结构，用来存储hash相同
 2 // 的所有key，value对结构。
 3 typedef union TKey {
 4   struct {
 5     TValuefields;       // key值
 6     struct Node *next;  // 指向像一个相同hash值的key值；
 7   } nk;
 8   TValue tvk;           //尾部的key值；
 9 } TKey;
10 
11 // (key，value）对结构，通过key计算获得的相同hash的Node保存在一个链表中；
12 typedef struct Node {
13   TValue i_val;
14   TKey i_key;
15 } Node;
16 
17 
18 typedef struct Table {
19   CommonHeader;
20   lu_byte flags;  
21   lu_byte lsizenode;   // Node数量 = 2^lsizenode 个Node结构
22   struct Table *metatable;
23   TValue *array;       // 数组方式存储的Node结构
24   Node *node;          // Node数组，数组的索引通过Key计算hash获取
25   Node *lastfree;      // 指向Node数组中的最后一个空闲Node，初始化为Node数组的最后一个值
26   GCObject *gclist;
27   int sizearray;       // 数组方式储存的Node结构数量，即数组大小
28 } Table;

Table *luaH_new (lua_State *L) {
  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h;
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  t->array = NULL;
  t->sizearray = 0;
  setnodevector(L, t, 0);
  return t;
}


void luaH_free (lua_State *L, Table *t) {
  if (!isdummy(t->node))
    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
  luaM_freearray(L, t->array, t->sizearray);
  luaM_free(L, t);
}

 1 /*
 2 ** search function for integers
 3 */
 4 const TValue *luaH_getint (Table *t, int key) {
 5   /* (1 <= key && key <= t->sizearray) */
 6   if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
 7     return &t->array[key-1];
 8   else {
 9     lua_Number nk = cast_num(key);
10     Node *n = hashnum(t, nk);
11     do {  /* check whether `key‘ is somewhere in the chain */
12       if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
13         return gval(n);  /* that‘s it */
14       else n = gnext(n);
15     } while (n);
16     return luaO_nilobject;
17   }
18 }
19 
20 void luaH_setint (lua_State *L, Table *t, int key, TValue *value) {
21   const TValue *p = luaH_getint(t, key);
22   TValue *cell;
23   if (p != luaO_nilobject)
24     cell = cast(TValue *, p);
25   else {
26     TValue k;
27     setnvalue(&k, cast_num(key));
28     cell = luaH_newkey(L, t, &k);
29   }
30   setobj2t(L, cell, value);
31 }

 1 const TValue *luaH_get (Table *t, const TValue *key) {
 2   switch (ttype(key)) {
 3     case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key));
 4     case LUA_TNIL: return luaO_nilobject;
 5     case LUA_TNUMBER: {
 6       int k;
 7       lua_Number n = nvalue(key);
 8       lua_number2int(k, n);
 9       if (luai_numeq(cast_num(k), n)) /* index is int? */
10         return luaH_getint(t, k);  /* use specialized version */
11       /* else go through */
12     }
13     default: {
14       Node *n = mainposition(t, key);
15       do {  /* check whether `key‘ is somewhere in the chain */
16         if (luaV_rawequalobj(gkey(n), key))
17           return gval(n);  /* that‘s it */
18         else n = gnext(n);
19       } while (n);
20       return luaO_nilobject;
21     }
22   }
23 }
24 
25 TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
26   const TValue *p = luaH_get(t, key);
27   if (p != luaO_nilobject)
28     return cast(TValue *, p);
29   else return luaH_newkey(L, t, key);
30 }
31 
32 static Node *mainposition (const Table *t, const TValue *key) {
33   switch (ttype(key)) {
34     case LUA_TNUMBER:
35       return hashnum(t, nvalue(key));
36     case LUA_TLNGSTR: {
37       TString *s = rawtsvalue(key);
38       if (s->tsv.extra == 0) {  /* no hash? */
39         s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash);
40         s->tsv.extra = 1;  /* now it has its hash */
41       }
42       return hashstr(t, rawtsvalue(key));
43     }
44     case LUA_TSHRSTR:
45       return hashstr(t, rawtsvalue(key));
46     case LUA_TBOOLEAN:
47       return hashboolean(t, bvalue(key));
48     case LUA_TLIGHTUSERDATA:
49       return hashpointer(t, pvalue(key));
50     case LUA_TLCF:
51       return hashpointer(t, fvalue(key));
52     default:
53       return hashpointer(t, gcvalue(key));
54   }
55 }