15 ** Tables keep its elements in two parts: an array part and a hash part.
17 ** part. The actual size of the array is the largest 'n' such that
50 ** MAXASIZE is the maximum size of the array part. It is the minimum
64 ** MAXHSIZE is the maximum size of the hash part. It is the minimum
241 ** part of table 't'. (Otherwise, the array part must be larger than
296 ** which may be in array part, nor for floats with integral values.)
316 ** the array part of a table, 0 otherwise.
328 ** elements in the array part, then elements in the hash part. The
336   if (i - 1u < asize)  /* is 'key' inside array part? */  in findindex()
352   for (; i < asize; i++) {  /* try first array part */  in luaH_next()
359   for (i -= asize; cast_int(i) < sizenode(t); i++) {  /* hash part */  in luaH_next()
384 ** Compute the optimal size for the array part of table 't'. 'nums' is a
388 ** will go to the array part; return the optimal size.  (The condition
395   unsigned int na = 0;  /* number of elements to go to array part */  in computesizes()
396   unsigned int optimal = 0;  /* optimal size for array part */  in computesizes()
404       na = a;  /* all elements up to 'optimal' will go to array part */  in computesizes()
425 ** Count keys in array part of table 't': Fill 'nums[i]' with
458   int ause = 0;  /* elements added to 'nums' (can go to array part) */  in numusehash()
474 ** Creates an array for the hash part of a table with the given
481   if (size == 0) {  /* no elements to hash part? */  in setnodevector()
506 ** (Re)insert all elements from the hash part of 'ot' into table 't'.
525 ** Exchange the hash part of 't1' and 't2'.
542 ** the hash part and for the array part) can fail, which creates some
543 ** subtleties. If the first allocation, for the hash part, fails, an
545 ** the shrinking part of the array (if it is shrinking) into the new
546 ** hash. Then it reallocates the array part.  If that fails, the table
547 ** is in its original state; the function frees the new hash part and then
548 ** raises the allocation error. Otherwise, it sets the new hash part
549 ** into the table, initializes the new part of the array (if any) with
556   Table newt;  /* to keep the new hash part */  in luaH_resize()
559   /* create new hash part with appropriate size into 'newt' */  in luaH_resize()
575     freehash(L, &newt);  /* release new hash part */  in luaH_resize()
578   /* allocation ok; initialize new part of the array */  in luaH_resize()
580   t->array = newarray;  /* set new array part */  in luaH_resize()
584   /* re-insert elements from old hash part into new parts */  in luaH_resize()
586   freehash(L, &newt);  /* free old hash part */  in luaH_resize()
599   unsigned int asize;  /* optimal size for array part */  in rehash()
600   unsigned int na;  /* number of keys in the array part */  in rehash()
606   na = numusearray(t, nums);  /* count keys in array part */  in rehash()
608   totaluse += numusehash(t, nums, &na);  /* count keys in hash part */  in rehash()
613   /* compute new size for array part */  in rehash()
724 ** directly from the array part. Otherwise, if 'alimit' is not equal to
725 ** the real size of the array, key still can be in the array part. In
733   else if (!limitequalsasize(t) &&  /* key still may be in the array part? */  in luaH_getint()
843 ** Try to find a boundary in the hash part of table 't'. From the
896 ** The code itself uses base 0 when indexing the array part of the table.)
898 ** part that may be a boundary.
910 ** last element of the array part. If it is empty, there must be a
915 ** (3) The last case is when there are no elements in the array part
917 ** In this case, must check the hash part. If there is no hash part
919 ** 'hash_search' to find a boundary in the hash part of the table.
920 ** (In those cases, the boundary is not inside the array part, and
959     /* else, new limit is present in the table; check the hash part */  in luaH_getn()