Lua5.1 源码注释(一) table.c

/*
** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $
** Lua tables (hash)
** See Copyright Notice in lua.h
*/

/*
** Implementation of tables (aka arrays, objects, or hash tables).
** Tables keep its elements in two parts: an array part and a hash part.
** Non-negative integer keys are all candidates to be kept in the array
** part. The actual size of the array is the largest `n' such that at
** least half the slots between 0 and n are in use.
** Hash uses a mix of chained scatter table with Brent's variation.
** A main invariant of these tables is that, if an element is not
** in its main position (i.e. the `original' position that its hash gives
** to it), then the colliding element is in its own main position.
** Hence even when the load factor reaches 100%, performance remains good.
*/

#include <math.h>
#include <string.h>

#define ltable_c
#define LUA_CORE

#include "lua.h"

#include "ldebug.h"
#include "ldo.h"
#include "lgc.h"
#include "lmem.h"
#include "lobject.h"
#include "lstate.h"
#include "ltable.h"

/*
** max size of array part is 2^MAXBITS
*/
#if LUAI_BITSINT > 26
#define MAXBITS		26
#else
#define MAXBITS		(LUAI_BITSINT-2)
#endif

#define MAXASIZE	(1 << MAXBITS)

#define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))

#define hashstr(t,str)  hashpow2(t, (str)->tsv.hash)
#define hashboolean(t,p)        hashpow2(t, p)

/*
** for some types, it is better to avoid modulus by power of 2, as
** they tend to have many 2 factors.
*/
#define hashmod(t,n)	(gnode(t, ((n) % ((sizenode(t)-1)|1))))//n对sizenode取模

#define hashpointer(t,p)	hashmod(t, IntPoint(p))

/*
** number of ints inside a lua_Number
*/
#define numints		cast_int(sizeof(lua_Number)/sizeof(int))

#define dummynode		(&dummynode_)

static const Node dummynode_ = { //这是一个静态的空node,key是空的，value也是空的，用来表示所有没有被分配空间的table
{{NULL}, LUA_TNIL},  /* value */
{{{NULL}, LUA_TNIL, NULL}}  /* key */
};

/*
** hash for lua_Numbers
*/
static Node *hashnum (const Table *t, lua_Number n) { //这个函数找出数字n的hash node,lua_Number事实上是double
unsigned int a[numints];//numints  通常是4
int i;
if (luai_numeq(n, 0))  /* avoid problems with -0 */ //这里是和
return gnode(t, 0);//假如是0的话，直接返回hash node的第一个
memcpy(a, &n, sizeof(a));//字节复制n的数据到a上面
for (i = 1; i < numints; i++) a[0] += a[i];//所谓hash,其实就是一字节一字节加起来放到a[0]，这种做法的hash分布可能不太理想，不过效率较快
return hashmod(t, a[0]);//a[0]就是hash值，返回这个hash节点的node
}

/*
** returns the `main' position of an element in a table (that is, the index
** of its hash value)
*/
static Node *mainposition (const Table *t, const TValue *key) {
switch (ttype(key)) {//找出key的类型
case LUA_TNUMBER:
return hashnum(t, nvalue(key));//是number hash
case LUA_TSTRING:
return hashstr(t, rawtsvalue(key));//string hash
case LUA_TBOOLEAN:
return hashboolean(t, bvalue(key));//布尔hash
case LUA_TLIGHTUSERDATA:
return hashpointer(t, pvalue(key));//指针hash
default:
return hashpointer(t, gcvalue(key));//默认的也是指针hash
}
}

/*
** returns the index for `key' if `key' is an appropriate key to live in
** the array part of the table, -1 otherwise.
*/
static int arrayindex (const TValue *key) {//候如key值可以放在 table的数值部分的话，就返回key的下标，否则返回-1
if (ttisnumber(key)) {//首先,key必须是number
lua_Number n = nvalue(key);//获得number的实际数值
int k;
lua_number2int(k, n);//将这个number转换成int，并且赋值给k
if (luai_numeq(cast_num(k), n))//假如转换后的k和原值是一样的，说明没有精度损失，n本身就是uint，返回它即可
return k;
}
return -1;  /* `key' did not match some condition */
}

/*
** returns the index of a `key' for table traversals. First goes all
** elements in the array part, then elements in the hash part. The
** beginning of a traversal is signalled by -1.
*/
//遍历table,返回key对应的下标，首先遍历数组部分，然后遍历hash部分，-1表示遍历开始
static int findindex (lua_State *L, Table *t, StkId key) {
int i;
if (ttisnil(key)) return -1;  /* first iteration */ //key是一个空值的话，返回-1
i = arrayindex(key);//找出key在数组中的index,如果不存在，arrayindex是会返回-1的
if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
return i-1;  /* yes; that's the index (corrected to C) */ //如果key在数组中存在，则返回它在数组中的c数组下标
else {
Node *n = mainposition(t, key); //在数组中不存在，开始在hash中找 key对应的hash node N
do {  /* check whether `key' is somewhere in the chain */
/* key may be dead already, but it is ok to use it in `next' */
if (luaO_rawequalObj(key2tval(n), key) ||
(ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
gcvalue(gkey(n)) == gcvalue(key))) {//检查key值是不是在hash的链表中， key == n则说明它在hash表中，或者key已经被回收了， 那么检查一下xxxxx
i = cast_int(n - gnode(t, 0));  /* key index in hash table */ //
/* hash elements are numbered after array ones */
return i + t->sizearray;//i是hash node的位置，要加上数组的长度
}
else n = gnext(n);//找node指向的下个node
} while (n);
luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */ //找不到这个key
return 0;  /* to avoid warnings */
}
}

int luaH_next (lua_State *L, Table *t, StkId key) { //找出key对应的下一个元素，并把它的值放在key里面
int i = findindex(L, t, key);  /* find original element */ //找出key在table中的索引
for (i++; i < t->sizearray; i++) {  /* try first array part */ //假如是在数组中
if (!ttisnil(&t->array[i])) {  /* a non-nil value? */ //遍历数组，一直找到下一个非空值为止
setnvalue(key, cast_num(i+1));//将key的值变成number,并赋i+1
setobj2s(L, key+1, &t->array[i]);//一是将array[i]的值赋给key+1指向的值
return 1;
}
}
for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */  //候如前面没有找到，就从hash里面找，i重置
if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */ //找出hash 中的i对应的值，是否为空，如果不是
setobj2s(L, key, key2tval(gnode(t, i)));//将i对应该的hash node的键值放在 key里面
setobj2s(L, key+1, gval(gnode(t, i))); //将i对应该的 hash node的 value值放在key +1
return 1;
}
}
return 0;  /* no more elements */
}

/*
** {=============================================================
** Rehash
** ==============================================================
*/

static int computesizes (int nums[], int *narray) { //计算size  //nums所有的值加起来得出的总值，和narray的值是一样大小的
int i;
int twotoi;  /* 2^i */
int a = 0;  /* number of elements smaller than 2^i */
int na = 0;  /* number of elements to go to array part */
int n = 0;  /* optimal size for array part */
for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
if (nums[i] > 0) {
a += nums[i];//a一直累加
if (a > twotoi/2) {  /* more than half elements present? */
n = twotoi;  /* optimal size (till now) */
na = a;  /* all elements smaller than n will go to array part */
}
}
if (a == *narray) break;  /* all elements already counted */ //直到a累加到上限，退出
}
*narray = n;
lua_assert(*narray/2 <= na && na <= *narray);//na的值应该大于narray的一半，小于narray，否则报错
return na;
}

static int countint (const TValue *key, int *nums) {//找出key在table中的索引，并将 nums下标为索引log2()的值自增1
int k = arrayindex(key);//找出key 在数组部分 的位置
if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
nums[ceillog2(k)]++;  /* count as such */  //取这个位置的log2
return 1;
}
else
return 0;
}

static int numusearray (const Table *t, int *nums) { //统计数组中的非空元素个数
int lg;
int ttlg;  /* 2^lg */
int ause = 0;  /* summation of `nums' */
int i = 1;  /* count to traverse all array keys */
for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {  /* for each slice */ //[1]={1-2},[2]={3-4},3={5-8},[4]={9-16},[5]={17-64)}...这样分组，从头到尾遍历非nil的元素，统计每个分组的个数，并返回总个数.
int lc = 0;  /* counter */
int lim = ttlg;
if (lim > t->sizearray) { //最后组不免2的n次幂时，以实现长度为准
lim = t->sizearray;  /* adjust upper limit */
if (i > lim)
break;  /* no more elements to count */ //上一轮已经没有数据了，开始新一轮时i>lim会退出
}
/* count elements in range (2^(lg-1), 2^lg] */
for (; i <= lim; i++) {//执行一轮统计,找出这一轮所有非空的元素
if (!ttisnil(&t->array[i-1]))
lc++;
}
nums[lg] += lc;
ause += lc;
}
return ause; //返回总数
}

static int numusehash (const Table *t, int *nums, int *pnasize) {
int totaluse = 0;  /* total number of elements */
int ause = 0;  /* summation of `nums' */
int i = sizenode(t);//找出hash的长度
while (i--) {
Node *n = &t->node[i];
if (!ttisnil(gval(n))) {
ause += countint(key2tval(n), nums);//找出key值所在的位置index，并将nums[log(index)]自加1，找到就返回1，找不到返回0
totaluse++;//总数加1
}
}
*pnasize += ause;//对应的数组总长度+1
return totaluse;//返回所有非空数量
}

static void setarrayvector (lua_State *L, Table *t, int size) {//重新分配table的数组内存
int i;
luaM_reallocvector(L, t->array, t->sizearray, size, TValue);//释放旧的内存，然后分配新的内存，因为是数组部分，所以不担心内存回收的问题，直接都释放了，话说这个东西真的不进行数据复制的，会不会太狠了？
for (i=t->sizearray; i<size; i++)//为什么后面的数据要设置为nil，前面的就不管了？luaM_reallocvector好像真的没有内存复制啊
setnilvalue(&t->array[i]);//设置nil
t->sizearray = size;//设置size
}

static void setnodevector (lua_State *L, Table *t, int size) { //设置hash表
int lsize;
if (size == 0) {  /* no elements to hash part? */ //假如新的长度是0
t->node = cast(Node *, dummynode);  /* use common `dummynode' */ //则将node指向空值
lsize = 0;//size设置为0
}
else {
int i;
lsize = ceillog2(size); //否则，lsize=size的log2，并向上取整
if (lsize > MAXBITS) //超出了最大容量
luaG_runerror(L, "table overflow");//报错
size = twoto(lsize);//将size变成lsize的平方
t->node = luaM_newvector(L, size, Node);// 分配一个新的长度的node
for (i=0; i<size; i++) {//初始化node
Node *n = gnode(t, i);
gnext(n) = NULL;//next指针清空
setnilvalue(gkey(n));//key 清空
setnilvalue(gval(n));//value清空
}
}
t->lsizenode = cast_byte(lsize);//新的size
t->lastfree = gnode(t, size);  /* all positions are free */ //所有的node都是可用的
}

static void resize (lua_State *L, Table *t, int nasize, int nhsize) { //重新分配size,nasize新数组长度，nhsize新hash表长度
int i;
int oldasize = t->sizearray;//旧数组长度
int oldhsize = t->lsizenode;//旧hash长度
Node *nold = t->node;  /* save old hash ... * /   //保存旧的hash表数据
if (nasize > oldasize)  /* array part must grow? */
setarrayvector(L, t, nasize); //假如新的数组长度旧的数级长度长，则配置新的数组
/* create new hash part with appropriate size */
setnodevector(L, t, nhsize);  //分配新的hash表
if (nasize < oldasize) {  /* array part must shrink? */
t->sizearray = nasize;//假如旧的数组长长比新的数组长度短，则收缩
/* re-insert elements from vanishing slice */
for (i=nasize; i<oldasize; i++) {//将收缩后的数据根据下标放入到hash表中
if (!ttisnil(&t->array[i])) //假如数组数据非空
setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);//将数据放入到key=i+1的hash里面，为什么i+1?因为lua的下标比c的下标大1
}
/* shrink array */
luaM_reallocvector(L, t->array, oldasize, nasize, TValue);//收缩数组同存空间
}
/* re-insert elements from hash part */
for (i = twoto(oldhsize) - 1; i >= 0; i--) {//遍历hash数据
Node *old = nold+i;//找出node
if (!ttisnil(gval(old)))//如果node的value非空，则将数据复制到新的hash表中
setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));//复制旧值到新node中
}
if (nold != dummynode)//释放非空的旧hash表数据
luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
}

void luaH_resizearray (lua_State *L, Table *t, int nasize) {//重新分配数组数据
int nsize = (t->node == dummynode) ? 0 : sizenode(t);//hash表的长度，如果table是空的话，则设置为0，如果是非空的话，则设置为table的hash长度
resize(L, t, nasize, nsize);//重新分配空间
}

static void rehash (lua_State *L, Table *t, const TValue *ek) {//重新分配hash数据
int nasize, na;
int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */ //定义一个nusm数组，用来记录 2^(i-1) and 2^i 之间已经使用了的数据数量
int i;
int totaluse;
for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */ //清空nums
nasize = numusearray(t, nums);  /* count keys in array part */ // //计算数组已经使用了的个数
totaluse = nasize;  /* all those keys are integer keys */
totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */ //计算hash中已经使用了的个数
/* count extra key */
nasize += countint(ek, nums); //计算额外的数据，ek假如可以放到array中的话，nums对应的位置+1,countint返回1，否则返回0
totaluse++;//totaluse无论ek可以放在数组还是hash，它都会加1
/* compute new size for array part */
na = computesizes(nums, &nasize); //计算新的数组的长度
/* resize the table to new computed sizes */
resize(L, t, nasize, totaluse - na); //重新分配空间，//为什么会这样重新分配？totaluse - na即是hash部分的长度是用已经分配了的长度来决定？
}

/*
** }=============================================================
*/

Table *luaH_new (lua_State *L, int narray, int nhash) {//分配一个新的table
Table *t = luaM_new(L, Table);//首先，分配table的空间
luaC_link(L, obj2gco(t), LUA_TTABLE);//这是什么鬼？将table放入到gc里面吗？应该是的
t->metatable = NULL;//元表是空
t->flags = cast_byte(~0);//flags是1，即是使用中？
/* temporary values (kept only if some malloc fails) */
t->array = NULL;//数组指针是空
t->sizearray = 0;//数组长度是空
t->lsizenode = 0;//hash长度是空
t->node = cast(Node *, dummynode);//node指向空
setarrayvector(L, t, narray);//分配数组空间
setnodevector(L, t, nhash);//分配hash空间
return t;
}

void luaH_free (lua_State *L, Table *t) {//释放table的内存
if (t->node != dummynode)//假如node 表不是空
luaM_freearray(L, t->node, sizenode(t), Node); //释放node 表
luaM_freearray(L, t->array, t->sizearray, TValue);//释放数组表
luaM_free(L, t);//释放table占的内存
}

static Node *getfreepos (Table *t) {	//找出一个空的node
while (t->lastfree-- > t->node) {		//向前找，直到第一个为止
if (ttisnil(gkey(t->lastfree)))		//假如当前的lastfree是空的话，
return t->lastfree;				//则返回这个lastfree
}
return NULL;  /* could not find a free place */
}

/*
** inserts a new key into a hash table; first, check whether key's main
** position is free. If not, check whether colliding node is in its main
** position or not: if it is not, move colliding node to an empty place and
** put new key in its main position; otherwise (colliding node is in its main
** position), new key goes to an empty position.
*/
/*插入一个新key到hash 表中，首先，检查key对应的main position是否是空的，如果不是，
则检查冲突的node是不是main position，如果不是，就应该将冲突的node移到一个新的空位置，
将新key放到main position。如果冲突的点就已经是main position，则将新key放到一个空白点*/
static TValue *newkey (lua_State *L, Table *t, const TValue *key) {
Node *mp = mainposition(t, key);
if (!ttisnil(gval(mp)) || mp == dummynode) { //mp的值不是空或者mp是空
Node *othern;
Node *n = getfreepos(t);  /* get a free place */ //找出一个空点
if (n == NULL) {  /* cannot find a free place? *///假如找不到，即是没有空间了，要重新分配
rehash(L, t, key);  /* grow table */
return luaH_set(L, t, key);  /* re-insert key into grown table */ //然后返回新分配空间后的点
}
lua_assert(n != dummynode);
othern = mainposition(t, key2tval(mp));// 通常key2tval(mp)的值就是ke,这里面不用key,重新取一次
if (othern != mp) {  /* is colliding node out of its main position? */ //假如有mp.key取出来的值不等于mp,这就尴尬了，说明是冲突的点
/* yes; move colliding node into free position */
while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */ //other-> ...->pre->mainposition,遍历，找出pre点
gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */ //将pre 点的next指针赋成n点
*n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */ //将mp的数据放进n时面
gnext(mp) = NULL;  /* now `mp' is free */ //然后清空mp的next指针
setnilvalue(gval(mp));//再新空mp的值

else {  /* colliding node is in its own main position */  //假如冲突node本来就应该放在mp上面
/* new node will go into free position */
gnext(n) = gnext(mp);  /* chain new position */ // 那么，将n插入到mp->{n}->next 中间
gnext(mp) = n;
mp = n;//将mp赋成n
}
}
gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;//将mp的key值变成key的什，
luaC_barriert(L, t, key);//这是什么鬼，是用来做内存回收的吧
lua_assert(ttisnil(gval(mp)));//断言mp的值必须是空，如果非空，有问题啊
return gval(mp);//返回mp node的value
}

/*
** search function for integers
*/
const TValue *luaH_getnum (Table *t, int key) {//获取key为数值的node的value
/* (1 <= key && key <= t->sizearray) */
if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray)) //假如key小于数组的长度，直接返回数组的数据
return &t->array[key-1];
else {
lua_Number nk = cast_num(key);//否则，查找hash里面的数据
Node *n = hashnum(t, nk); //找出hash node
do {  /* check whether `key' is somewhere in the chain */
if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk)) //假如node n的key是数值，并且这个数值和nk相等的话
return gval(n);  /* that's it */ //返回 node的value,
else n = gnext(n);//否则，查找下一个
} while (n);//直到下一个是空为止
return luaO_nilobject;//返回空
}
}

/*
** search function for strings
*/
const TValue *luaH_getstr (Table *t, TString *key) {//返回key为字付串的node的value
Node *n = hashstr(t, key); //将key转换成hash值，并且访问表中对应的 node
do {  /* check whether `key' is somewhere in the chain */
if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)//假如这个node的key是string,并且和参数key相等，则返回node的值
return gval(n);  /* that's it */ //就是它了
else n = gnext(n); //如果不是，则找node的下一个，继续对比
} while (n);
return luaO_nilobject;//找不到，返回nil
}

/*
** main search function
*/
const TValue *luaH_get (Table *t, const TValue *key) { //找出key在table中的value
switch (ttype(key)) {
case LUA_TNIL: return luaO_nilobject; //空key,返回空值
case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));//字符串的key,找hash
case LUA_TNUMBER: {//数值key
int k;
lua_Number n = nvalue(key); //找出key的double值
lua_number2int(k, n);//转成int
if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */ //假如double和int值是一样的
return luaH_getnum(t, k);  /* use specialized version */ //luaH_getnum先从array里面查找，如果找不到，就从hash里面查找
/* else go through */
}
default: {
Node *n = mainposition(t, key);//其它的默认情况，先从hash中找出main postion
do {  /* check whether `key' is somewhere in the chain */
if (luaO_rawequalObj(key2tval(n), key))// //然后对比main position和key值是否相等
return gval(n);  /* that's it */ //假如相等则返回，
else n = gnext(n);//假如不等，则通过main position 的next指针找下一个
} while (n);//一直找到空的为止
return luaO_nilobject;// 最后找不到的就返回空
}
}
}

TValue *luaH_set (lua_State *L, Table *t, const TValue *key) { //设置table key,返回一个Tvalue的指针
const TValue *p = luaH_get(t, key);//找出key对应的Tvalue
t->flags = 0; //这是什么鬼？加锁吗？
if (p != luaO_nilobject) //假如p不等于nil,
return cast(TValue *, p);//将p转换成TValue指针，为嘛要转换？前面不用const不就可以了
else {
if (ttisnil(key)) luaG_runerror(L, "table index is nil"); //假如P是nil,则检查key,如果key是nil，则报错
else if (ttisnumber(key) && luai_numisnan(nvalue(key)))//如果key是数值，并且是nan,同样报错.
luaG_runerror(L, "table index is NaN");
return newkey(L, t, key);//否则，插入一个新key
}
}

TValue *luaH_setnum (lua_State *L, Table *t, int key) { //设置key是数值的value,返回value的指针，这样就可以通过修改指针改值
const TValue *p = luaH_getnum(t, key);//找出key对应的value
if (p != luaO_nilobject)//假如是空，则
return cast(TValue *, p);//则直接返回tvalue指针
else {
TValue k;
setnvalue(&k, cast_num(key));//否则，将k转成Tvalue,
return newkey(L, t, &k);//然后插入新node,返回node的value
}
}

TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {//设置key是string的value
const TValue *p = luaH_getstr(t, key);//获得value
if (p != luaO_nilobject)//假如非空
return cast(TValue *, p);//则直接返回tvalue指针
else {//假如是空
TValue k;
setsvalue(L, &k, key);//生成一个新key
return newkey(L, t, &k);//插入node中
}
}

static int unbound_search (Table *t, unsigned int j) {
unsigned int i = j;  /* i is zero or a present index */ //先记录j坐标
j++; //j下一个元素
/* find `i' and `j' such that i is present and j is not */
while (!ttisnil(luaH_getnum(t, j))) {//j对应的元素不是nil的话，要继续找下去
i = j;//记录一下不是nil的j
j *= 2;//j double，晕，又是倍数增长
if (j > cast(unsigned int, MAX_INT)) {  /* overflow? */ //2倍就超长啦,丧尽天良，回复到线性查找 吧
/* table was built with bad purposes: resort to linear search */
i = 1; //从1开始
while (!ttisnil(luaH_getnum(t, i))) i++;//
return i - 1;
}
}
/* now do a binary search between them */
while (j - i > 1) { //j在前面就已经2倍增长了，一直增长到luaH_getnum(t, j)为空时
unsigned int m = (i+j)/2;//折半查找
if (ttisnil(luaH_getnum(t, m))) j = m;//假如中间也是空，则j=m
else i = m;//假如中间不是空，则i=m
}
return i;
}

/*
** Try to find a boundary in table `t'. A `boundary' is an integer index
** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
*/
int luaH_getn (Table *t) { //找出table的边界i,这个i指t[i]是非空的，t[i+1]是空的
unsigned int j = t->sizearray;
if (j > 0 && ttisnil(&t->array[j - 1])) {//假如数组最后一个是空，则肯定是在数组里面
/* there is a boundary in the array part: (binary) search for it */
unsigned int i = 0;
while (j - i > 1) {
unsigned int m = (i+j)/2;//居然是用折半查找 的方法，汗
if (ttisnil(&t->array[m - 1])) j = m;//假如中间的是空，则从开始到中间之间找
else i = m;//否则从中间到最后之间找
}
return i;//当中间没有数值时
}
/* else must find a boundary in hash part */ //走到这里，前明前面的数组部分全是满的(其实就是数组最后一个值是非空的而已)
else if (t->node == dummynode)  /* hash part is empty? */ //假如hash部分就是空的话，直接返回数组长度
return j;  /* that is easy... */
else return unbound_search(t, j);//否则，开始调用unbound_search找出，unbound_search也是二分法查找hash 表部份
}

#if defined(LUA_DEBUG)

Node *luaH_mainposition (const Table *t, const TValue *key) {// 返回key值对应的node，只是封装了一下mainposition
return mainposition(t, key);
}

int luaH_isdummy (Node *n) { return n == dummynode; }//判断这个node是不是假的

#endif