You can drag and drop the map marker to the location where you want to calculate the distance between.
& The red line on the map indicates the Great Circle Distance.
& The black line is the Rhumb line between the two points.
& The blue line indicates the driving distance route.
Distance calculator helps you to find how many miles from a city to an another city on map.
Distance between cities or 2 locations are measured in both kilometers, miles and nautical miles at the same time.
Air distance is the bird fly distance between two locations which is calculated with the great circle formula.
nmi: is the symbol of nautical miles in distance calculation.
Distance Calculator Updates
Now we are using Vincenty's formula for more accurate results in our distance between cities pages.
Distance from to is now more mobile friendly with the new design.
We launched our distance from to
pages, please follow us for news and updates.
We've updated the cities of country pages, distance between major cities are now listed. And the list of cities of a country are updated.
Error while calculating driving distance is fixed.
Thanks to John M., Christian B., Renée H., Paul S. for feedback.
Target and destination city and place name inputs are now empty.
Thanks to Mark S. for feedback.
The black line information updated,thanks to Norman G. for feedback.
You can now calculate distance between two coordinates (two Latitude Longitude values).
Example: In the "From" value write "51..439896" and in the "To" value write the target location coordinates like: "21." .
I've updated our website interface with a modern look and more compatible with mobile devices,
I hope you like the new design, please contact me for your thoughts and ideas.
Meaning of color of lines added as legend info, thanks to Jim M. and Andy F. for feedback.
Scale control added to distance map, thanks to Tim D. for feedback.
Now we calculate nautical miles for distance between, thanks to Travis S. for feedback.
Interface updated, website font and background color changed for better reading.
Driving distance calculation error fixed. Thanks to John C. for feedback.
Driving distance calculation added, with bird fly air distance option.
Improved page speed for faster calculation of distance. Images and content optimized.
Here we have brand new design, which is responsive that means, you can browse distancefromto.net with your any mobile
device, and distancefromto will auto resize it self, hope you enjoy new features.
Distance between cities are now listed in . Select cities and measure distance.
I've changed maps version to 3 and distance calculation methods, distance between cities and places are faster and more reliable now. If you get 0 km distance measure please hit the button again.
to calculate time, add and subtract hours, minutes.
Helpful converters
City to City, place to place distance calculator.Lua源码分析
从今天起，我要注释完lua 的所有源码，现在发布第一篇，我要坚持，坚持，坚持完成这个注释工作，哈哈。 &
本来第一篇打算一周内就可以完成的，妈蛋，注释了一个月才完成。
现在，发布第一个文件，table.c，
** $Id: ltable.c,v 2.32.1.2
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
#define MAXBITS
(LUAI_BITSINT-2)
#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}}
** hash for lua_Numbers
static Node *hashnum (const Table *t, lua_Number n) { //这个函数找出数字n的hash node,lua_Number事实上是double
unsigned int a[numints];//numints
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 & 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
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的实际数值
lua_number2int(k, n);//将这个number转换成int，并且赋值给k
if (luai_numeq(cast_num(k), n))//假如转换后的k和原值是一样的，说明没有精度损失，n本身就是uint，返回它即可
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) {
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;
/* that's the index (corrected to C) */ //如果key在数组中存在，则返回它在数组中的c数组下标
Node *n = mainposition(t, key); //在数组中不存在，开始在hash中找 key对应的hash node N
/* 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-&//i是hash node的位置，要加上数组的长度
else n = gnext(n);//找node指向的下个node
} while (n);
luaG_runerror(L, &invalid key to & LUA_QL(&next&));
/* key not found */ //找不到这个key
/* 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-& 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指向的值
for (i -= t-& 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
/* no more elements */
** {=============================================================
** ==============================================================
static int computesizes (int nums[], int *narray) { //计算size
//nums所有的值加起来得出的总值，和narray的值是一样大小的
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 & * i++, twotoi *= 2) {
if (nums[i] & 0) {
a += nums[i];//a一直累加
if (a & twotoi/2) {
/* more than half elements present? */
/* optimal size (till now) */
/* all elements smaller than n will go to array part */
if (a == *narray)
/* all elements already counted */ //直到a累加到上限，退出
lua_assert(*narray/2 &= na && na &= *narray);//na的值应该大于narray的一半，小于narray，否则报错
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
static int numusearray (const Table *t, int *nums) { //统计数组中的非空元素个数
/* 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 */
if (lim & t-&sizearray) { //最后组不免2的n次幂时，以实现长度为准
/* adjust upper limit */
if (i & lim)
/* no more elements to count */ //上一轮已经没有数据了，开始新一轮时i&lim会退出
/* count elements in range (2^(lg-1), 2^lg] */
for (; i &= i++) {//执行一轮统计,找出这一轮所有非空的元素
if (!ttisnil(&t-&array[i-1]))
nums[lg] +=
//返回总数
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 +=//对应的数组总长度+1
//返回所有非空数量
static void setarrayvector (lua_State *L, Table *t, int size) {//重新分配table的数组内存
luaM_reallocvector(L, t-&array, t-&sizearray, size, TValue);//释放旧的内存，然后分配新的内存，因为是数组部分，所以不担心内存回收的问题，直接都释放了，话说这个东西真的不进行数据复制的，会不会太狠了？
for (i=t-& i& i++)//为什么后面的数据要设置为nil，前面的就不管了？luaM_reallocvector好像真的没有内存复制啊
setnilvalue(&t-&array[i]);//设置nil
t-&sizearray =//设置size
static void setnodevector (lua_State *L, Table *t, int size) { //设置hash表
if (size == 0) {
/* no elements to hash part? */ //假如新的长度是0
t-&node = cast(Node *, dummynode);
/* use common `dummynode' */ //则将node指向空值
lsize = 0;//size设置为0
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& 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 oldasize = t-&//旧数组长度
int oldhsize = t-&//旧hash长度
Node *nold = t-&
/* 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 =//假如旧的数组长长比新的数组长度短，则收缩
/* re-insert elements from vanishing slice */
for (i= i& 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,
int nums[MAXBITS+1];
/* nums[i] = number of keys between 2^(i-1) and 2^i */ //定义一个nusm数组，用来记录 2^(i-1) and 2^i 之间已经使用了的数据数量
for (i=0; i&=MAXBITS; i++) nums[i] = 0;
/* reset counts */ //清空nums
nasize = numusearray(t, nums);
/* count keys in array part */ // //计算数组已经使用了的个数
totaluse =
/* 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空间
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
return NULL;
/* could not find a free place */
** inserts a new k 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
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 *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,这就尴尬了，说明是冲突的点
/* move colliding node into free position */
while (gnext(othern) != mp) othern = gnext(othern);
/* find previous */ //other-& ...-&pre-&mainposition,遍历，找出pre点
gnext(othern) =
/* redo the chain with `n' in place of `mp' */ //将pre 点的next指针赋成n点
/* 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的值
/* 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) =
mp =//将mp赋成n
gkey(mp)-&value = key-& gkey(mp)-&tt = key-&//将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];
lua_Number nk = cast_num(key);//否则，查找hash里面的数据
Node *n = hashnum(t, nk); //找出hash node
/* 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_//返回空
** search function for strings
const TValue *luaH_getstr (Table *t, TString *key) {//返回key为字付串的node的value
Node *n = hashstr(t, key); //将key转换成hash值，并且访问表中对应的 node
/* 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_//找不到，返回nil
** main search function
const TValue *luaH_get (Table *t, const TValue *key) { //找出key在table中的value
switch (ttype(key)) {
case LUA_TNIL: return luaO_ //空key,返回空值
case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));//字符串的key,找hash
case LUA_TNUMBER: {//数值key
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
/* 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_// 最后找不到的就返回空
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不就可以了
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指针
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 {//假如是空
setsvalue(L, &k, key);//生成一个新key
return newkey(L, t, &k);//插入node中
static int unbound_search (Table *t, unsigned int j) {
unsigned int i =
/* 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 =//记录一下不是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 =//假如中间也是空，则j=m
else i =//假如中间不是空，则i=m
** 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-&
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 =//假如中间的是空，则从开始到中间之间找
else i =//否则从中间到最后之间找
//当中间没有数值时
/* else must find a boundary in hash part */ //走到这里，前明前面的数组部分全是满的(其实就是数组最后一个值是非空的而已)
else if (t-&node == dummynode)
/* hash part is empty? */ //假如hash部分就是空的话，直接返回数组长度
/* 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 == }//判断这个node是不是假的
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：8322次
排名：千里之外
(1)(1)(1)(1)(1)}