public int invoke(LuaState vm) {
switch (id) {
/* Load the table library dynamically
*/
case INSTALL:
install(vm._G);
return 0;
/* table.concat (table [, sep [, i [, j]]])
*
* Given an array where all elements are strings or numbers, returns table[i]..sep..table[i+1] ··· sep..table[j].
* The default value for sep is the empty string, the default for i is 1, and the default for j is the length of the table.
* If i is greater than j, returns the empty string.
*/
case CONCAT:
{
// int n = vm.gettop();
LTable table = vm.checktable(1);
LString sep = vm.optlstring(2, null);
int i = vm.optint(3, 1);
int j = vm.optint(4, -1);
if (j == -1) j = table.luaLength();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
for (int k = i; k <= j; k++) {
LValue v = table.get(k);
if (!v.isString()) vm.argerror(1, "table contains non-strings");
v.luaConcatTo(baos);
if (k < j && sep != null) sep.luaConcatTo(baos);
}
vm.pushlstring(baos.toByteArray());
return 1;
}
/* table.getn (table)
*
* Get length of table t.
*/
case FOREACH:
case FOREACHI:
{
LTable table = vm.checktable(1);
LFunction function = vm.checkfunction(2);
vm.pushlvalue(table.foreach(vm, function, id == FOREACHI));
return 1;
}
/* table.getn (table)
*
* Get length of table t.
*/
case GETN:
{
LTable table = vm.checktable(1);
vm.pushinteger(table.luaLength());
return 1;
}
/* table.insert (table, [pos,] value)
*
* Inserts element value at position pos in table, shifting up other elements to open space, if necessary.
* The default value for pos is n+1, where n is the length of the table (see §2.5.5), so that a call
* table.insert(t,x) inserts x at the end of table t.
*/
case INSERT:
{
LTable table = vm.checktable(1);
int pos = 0;
switch (vm.gettop()) {
case 2:
break;
case 3:
pos = vm.checkint(2);
break;
default:
vm.error("wrong number of arguments to 'insert'");
}
table.luaInsertPos(pos, vm.topointer(-1));
return 0;
}
/* table.maxn (table)
*
* Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical
* indices. (To do its job this function does a linear traversal of the whole table.)
*/
case MAXN:
{
LTable table = vm.checktable(1);
vm.pushlvalue(table.luaMaxN());
return 1;
}
/* table.remove (table [, pos])
*
* Removes from table the element at position pos, shifting down other elements to close the space, if necessary.
* Returns the value of the removed element. The default value for pos is n, where n is the length of the table,
* so that a call table.remove(t) removes the last element of table t.
*/
case REMOVE:
{
LTable table = vm.checktable(1);
int pos = vm.optint(2, 0);
LValue v = table.luaRemovePos(pos);
vm.pushlvalue(v);
return v.isNil() ? 0 : 1;
}
/* table.sort (table [, comp])
*
* Sorts table elements in a given order, in-place, from table[1] to table[n], where n is the length of the table.
* If comp is given, then it must be a function that receives two table elements, and returns true when the first
* is less than the second (so that not comp(a[i+1],a[i]) will be true after the sort). If comp is not given,
* then the standard Lua operator < is used instead.
*
* The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.
*/
case SORT:
{
LTable table = vm.checktable(1);
LValue compare = (vm.isnoneornil(2) ? (LValue) LNil.NIL : (LValue) vm.checkfunction(2));
table.luaSort(vm, compare);
return 0;
}
default:
LuaState.vmerror("bad table id");
return 0;
}
}
public static void install(LTable globals) {
LTable table = new LTable();
for (int i = 1; i < NAMES.length; i++) table.put(NAMES[i], new TableLib(i));
globals.put("table", table);
PackageLib.setIsLoaded("table", table);
}
