Package party.iroiro.luajava

Interface LuaNatives

All Known Implementing Classes:
Lua51Natives, Lua52Natives, Lua53Natives, Lua54Natives, Lua55Natives, LuaJitNatives, LuaJNatives
@NullUnmarked public interface LuaNatives
Generated from the common parts of Lua5.[1..4]

The following documentation is copied from that of Lua 5.1. There might be inconsistencies between versions. So please check the official Lua documentation to confirm.

  • Method Details

    • loadAsGlobal

      void loadAsGlobal()
      Exposes the symbols in the natives to external libraries.

      Users are only allowed load one instance of natives if they want it global. Otherwise, the JVM might just crash due to identical symbol names in different binaries.

    • lua_tonumber

      double lua_tonumber(long ptr, int index)
      Wrapper of lua_tonumber 
      
 [-0, +0, -]
 
      
 lua_Number lua_tonumber (lua_State *L, int index);

      Converts the Lua value at the given acceptable index to the C type lua_Number (see lua_Number). The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tonumber returns 0.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • getRegistryIndex

      int getRegistryIndex()
      Returns the Lua registry index constant.
      Returns:
      the LUA_REGISTRYINDEX constant, which changes between versions

    • lua_checkstack

      int lua_checkstack(long ptr, int n)
      Wrapper of lua_checkstack 
      
 [-0, +0, m]
 
      
 int lua_checkstack (lua_State *L, int extra);

      Ensures that there are at least extra free stack slots in the stack. It returns false if it cannot grow the stack to that size. This function never shrinks the stack; if the stack is already larger than the new size, it is left unchanged.

      Parameters:
      ptr - the lua_State* pointer
      n - slots
      Returns:
      see description

    • lua_error

      int lua_error(long ptr)
      Wrapper of lua_error 
      
 [-1, +0, v]
 
      
 int lua_error (lua_State *L);

      Generates a Lua error. The error message (which can actually be a Lua value of any type) must be on the stack top. This function does a long jump, and therefore never returns. (see luaL_error).

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_gethookcount

      int lua_gethookcount(long ptr)
      Wrapper of lua_gethookcount 
      
 [-0, +0, -]
 
      
 int lua_gethookcount (lua_State *L);

      Returns the current hook count.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_gethookmask

      int lua_gethookmask(long ptr)
      Wrapper of lua_gethookmask 
      
 [-0, +0, -]
 
      
 int lua_gethookmask (lua_State *L);

      Returns the current hook mask.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_getmetatable

      int lua_getmetatable(long ptr, int index)
      Wrapper of lua_getmetatable 
      
 [-0, +(0|1), -]
 
      
 int lua_getmetatable (lua_State *L, int index);

      Pushes onto the stack the metatable of the value at the given acceptable index. If the index is not valid, or if the value does not have a metatable, the function returns 0 and pushes nothing on the stack.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_gettop

      int lua_gettop(long ptr)
      Wrapper of lua_gettop 
      
 [-0, +0, -]
 
      
 int lua_gettop (lua_State *L);

      Returns the index of the top element in the stack. Because indices start at 1, this result is equal to the number of elements in the stack (and so 0 means an empty stack).

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_isboolean

      int lua_isboolean(long ptr, int index)
      Wrapper of lua_isboolean 
      
 [-0, +0, -]
 
      
 int lua_isboolean (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index has type boolean, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_iscfunction

      int lua_iscfunction(long ptr, int index)
      Wrapper of lua_iscfunction 
      
 [-0, +0, -]
 
      
 int lua_iscfunction (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a C function, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isfunction

      int lua_isfunction(long ptr, int index)
      Wrapper of lua_isfunction 
      
 [-0, +0, -]
 
      
 int lua_isfunction (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a function (either C or Lua), and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_islightuserdata

      int lua_islightuserdata(long ptr, int index)
      Wrapper of lua_islightuserdata 
      
 [-0, +0, -]
 
      
 int lua_islightuserdata (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a light userdata, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isnil

      int lua_isnil(long ptr, int index)
      Wrapper of lua_isnil 
      
 [-0, +0, -]
 
      
 int lua_isnil (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is nil, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isnone

      int lua_isnone(long ptr, int index)
      Wrapper of lua_isnone 
      
 [-0, +0, -]
 
      
 int lua_isnone (lua_State *L, int index);

      Returns 1 if the given acceptable index is not valid (that is, it refers to an element outside the current stack), and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isnoneornil

      int lua_isnoneornil(long ptr, int index)
      Wrapper of lua_isnoneornil 
      
 [-0, +0, -]
 
      
 int lua_isnoneornil (lua_State *L, int index);

      Returns 1 if the given acceptable index is not valid (that is, it refers to an element outside the current stack) or if the value at this index is nil, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isnumber

      int lua_isnumber(long ptr, int index)
      Wrapper of lua_isnumber 
      
 [-0, +0, -]
 
      
 int lua_isnumber (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a number or a string convertible to a number, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isstring

      int lua_isstring(long ptr, int index)
      Wrapper of lua_isstring 
      
 [-0, +0, -]
 
      
 int lua_isstring (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a string or a number (which is always convertible to a string), and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_istable

      int lua_istable(long ptr, int index)
      Wrapper of lua_istable 
      
 [-0, +0, -]
 
      
 int lua_istable (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a table, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isthread

      int lua_isthread(long ptr, int index)
      Wrapper of lua_isthread 
      
 [-0, +0, -]
 
      
 int lua_isthread (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a thread, and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_isuserdata

      int lua_isuserdata(long ptr, int index)
      Wrapper of lua_isuserdata 
      
 [-0, +0, -]
 
      
 int lua_isuserdata (lua_State *L, int index);

      Returns 1 if the value at the given acceptable index is a userdata (either full or light), and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • luaJ_compare

      int luaJ_compare(long ptr, int index1, int index2, int op)
      A wrapper function

      See lua_compare

      Parameters:
      ptr - the lua_State* pointer
      index1 - the stack position of the first element
      index2 - the stack position of the second element
      op - the operator
      Returns:
      see description

    • luaJ_dobuffer

      int luaJ_dobuffer(long ptr, Buffer buffer, int start, int size, String name)
      A wrapper function

      Run a direct buffer

      Parameters:
      ptr - the lua_State* pointer
      buffer - the buffer (expecting direct)
      start - the starting index
      size - size
      name - the name
      Returns:
      see description

    • luaJ_initloader

      int luaJ_initloader(long ptr)
      A wrapper function

      Append a searcher loading from Java side into package.searchers / loaders

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • luaJ_invokespecial

      int luaJ_invokespecial(long ptr, Class clazz, String method, String sig, Object obj, String params)
      A wrapper function

      Runs CallNonvirtual<type>MethodA. See AbstractLua for usages. Parameters should be boxed and pushed on stack.

      Parameters:
      ptr - the lua_State* pointer
      clazz - the Java class
      method - the method name
      sig - the method signature used in GetMethodID
      obj - the Java object
      params - encoded parameter types
      Returns:
      see description

    • luaJ_isinteger

      int luaJ_isinteger(long ptr, int index)
      Wrapper of lua_isinteger 
      
 [-0, +0, –]
 
      
 int lua_isinteger (lua_State *L, int index);

      Returns 1 if the value at the given index is an integer (that is, the value is a number and is represented as an integer), and 0 otherwise.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • luaJ_isobject

      int luaJ_isobject(long ptr, int index)
      A wrapper function

      Is a Java object (including object, array or class)

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • luaJ_len

      int luaJ_len(long ptr, int index)
      A wrapper function

      Wrapper of lua_(obj)len

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • luaJ_loadbuffer

      int luaJ_loadbuffer(long ptr, Buffer buffer, int start, int size, String name)
      A wrapper function

      Load a direct buffer

      Parameters:
      ptr - the lua_State* pointer
      buffer - the buffer (expecting direct)
      start - the starting index
      size - size
      name - the name
      Returns:
      see description

    • luaJ_resume

      int luaJ_resume(long ptr, int nargs)
      A wrapper function

      Resume a coroutine

      Parameters:
      ptr - the lua_State* pointer
      nargs - the number of arguments that you pushed onto the stack
      Returns:
      see description

    • luaL_callmeta

      int luaL_callmeta(long ptr, int obj, String e)
      Wrapper of luaL_callmeta 
      
 [-0, +(0|1), e]
 
      
 int luaL_callmeta (lua_State *L, int obj, const char *e);

      Calls a metamethod.

      If the object at index obj has a metatable and this metatable has a field e, this function calls this field and passes the object as its only argument. In this case this function returns 1 and pushes onto the stack the value returned by the call. If there is no metatable or no metamethod, this function returns 0 (without pushing any value on the stack).

      Parameters:
      ptr - the lua_State* pointer
      obj - the stack position of the object
      e - field name
      Returns:
      see description

    • luaL_dostring

      int luaL_dostring(long ptr, String str)
      Wrapper of luaL_dostring 
      
 [-0, +?, m]
 
      
 int luaL_dostring (lua_State *L, const char *str);

      Loads and runs the given string. It is defined as the following macro: 

            (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))

      It returns 0 if there are no errors or 1 in case of errors.

      Parameters:
      ptr - the lua_State* pointer
      str - string
      Returns:
      see description

    • luaL_getmetafield

      int luaL_getmetafield(long ptr, int obj, String e)
      Wrapper of luaL_getmetafield 
      
 [-0, +(0|1), m]
 
      
 int luaL_getmetafield (lua_State *L, int obj, const char *e);

      Pushes onto the stack the field e from the metatable of the object at index obj. If the object does not have a metatable, or if the metatable does not have this field, returns 0 and pushes nothing.

      Parameters:
      ptr - the lua_State* pointer
      obj - the stack position of the object
      e - field name
      Returns:
      see description

    • luaL_loadstring

      int luaL_loadstring(long ptr, String s)
      Wrapper of luaL_loadstring 
      
 [-0, +1, m]
 
      
 int luaL_loadstring (lua_State *L, const char *s);

      Loads a string as a Lua chunk. This function uses lua_load to load the chunk in the zero-terminated string s.

      This function returns the same results as lua_load.

      Also as lua_load, this function only loads the chunk; it does not run it.

      Parameters:
      ptr - the lua_State* pointer
      s - the string
      Returns:
      see description

    • luaL_newmetatable

      int luaL_newmetatable(long ptr, String tname)
      Wrapper of luaL_newmetatable 
      
 [-0, +1, m]
 
      
 int luaL_newmetatable (lua_State *L, const char *tname);

      If the registry already has the key tname, returns 0. Otherwise, creates a new table to be used as a metatable for userdata, adds it to the registry with key tname, and returns 1.

      In both cases pushes onto the stack the final value associated with tname in the registry.

      Parameters:
      ptr - the lua_State* pointer
      tname - type name
      Returns:
      see description

    • luaL_ref

      int luaL_ref(long ptr, int t)
      Wrapper of luaL_ref 
      
 [-1, +0, m]
 
      
 int luaL_ref (lua_State *L, int t);

      Creates and returns a reference, in the table at index t, for the object at the top of the stack (and pops the object).

      A reference is a unique integer key. As long as you do not manually add integer keys into table t, luaL_ref ensures the uniqueness of the key it returns. You can retrieve an object referred by reference r by calling lua_rawgeti(L, t, r). Function luaL_unref frees a reference and its associated object.

      If the object at the top of the stack is nil, luaL_ref returns the constant LUA_REFNIL. The constant LUA_NOREF is guaranteed to be different from any reference returned by luaL_ref.

      Parameters:
      ptr - the lua_State* pointer
      t - the stack index
      Returns:
      see description

    • lua_next

      int lua_next(long ptr, int index)
      Wrapper of lua_next 
      
 [-1, +(2|0), e]
 
      
 int lua_next (lua_State *L, int index);

      Pops a key from the stack, and pushes a key-value pair from the table at the given index (the "next" pair after the given key). If there are no more elements in the table, then lua_next returns 0 (and pushes nothing).

      A typical traversal looks like this: 

            /* table is in the stack at index 't' */
      lua_pushnil(L);  /* first key */
      while (lua_next(L, t) != 0) {
        /* uses 'key' (at index -2) and 'value' (at index -1) */
        printf("%s - %s\n",
               lua_typename(L, lua_type(L, -2)),
               lua_typename(L, lua_type(L, -1)));
        /* removes 'value'; keeps 'key' for next iteration */
        lua_pop(L, 1);
      }

      While traversing a table, do not call lua_tolstring directly on a key, unless you know that the key is actually a string. Recall that lua_tolstring changes the value at the given index; this confuses the next call to lua_next.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_pcall

      int lua_pcall(long ptr, int nargs, int nresults, int msgh)
      Wrapper of lua_pcall 
      
 [-(nargs + 1), +(nresults|1), -]
 
      
 int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);

      Calls a function in public mode.

      Both nargs and nresults have the same meaning as in lua_call. If there are no errors during the call, lua_pcall behaves exactly like lua_call. However, if there is any error, lua_pcall catches it, pushes a single value on the stack (the error message), and returns an error code. Like lua_call, lua_pcall always removes the function and its arguments from the stack.

      If errfunc is 0, then the error message returned on the stack is exactly the original error message. Otherwise, errfunc is the stack index of an error handler function. (In the current implementation, this index cannot be a pseudo-index.) In case of runtime errors, this function will be called with the error message and its return value will be the message returned on the stack by lua_pcall.

      Typically, the error handler function is used to add more debug information to the error message, such as a stack traceback. Such information cannot be gathered after the return of lua_pcall, since by then the stack has unwound.

      The lua_pcall function returns 0 in case of success or one of the following error codes (defined in lua.h):

      • LUA_ERRRUN: a runtime error.
      • LUA_ERRMEM: memory allocation error. For such errors, Lua does not call the error handler function.
      • LUA_ERRERR: error while running the error handler function.
      Parameters:
      ptr - the lua_State* pointer
      nargs - the number of arguments that you pushed onto the stack
      nresults - the number of results, or LUA_MULTRET
      msgh - 0 or the stack index of an error handler function
      Returns:
      see description

    • lua_pushthread

      int lua_pushthread(long ptr)
      Wrapper of lua_pushthread 
      
 [-0, +1, -]
 
      
 int lua_pushthread (lua_State *L);

      Pushes the thread represented by L onto the stack. Returns 1 if this thread is the main thread of its state.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_rawequal

      int lua_rawequal(long ptr, int index1, int index2)
      Wrapper of lua_rawequal 
      
 [-0, +0, -]
 
      
 int lua_rawequal (lua_State *L, int index1, int index2);

      Returns 1 if the two values in acceptable indices index1 and index2 are primitively equal (that is, without calling metamethods). Otherwise returns 0. Also returns 0 if any of the indices are non valid.

      Parameters:
      ptr - the lua_State* pointer
      index1 - the stack position of the first element
      index2 - the stack position of the second element
      Returns:
      see description

    • lua_status

      int lua_status(long ptr)
      Wrapper of lua_status 
      
 [-0, +0, -]
 
      
 int lua_status (lua_State *L);

      Returns the status of the thread L.

      The status can be 0 for a normal thread, an error code if the thread finished its execution with an error, or LUA_YIELD if the thread is suspended.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_toboolean

      int lua_toboolean(long ptr, int index)
      Wrapper of lua_toboolean 
      
 [-0, +0, -]
 
      
 int lua_toboolean (lua_State *L, int index);

      Converts the Lua value at the given acceptable index to a C boolean value (0 or 1). Like all tests in Lua, lua_toboolean returns 1 for any Lua value different from false and nil; otherwise it returns 0. It also returns 0 when called with a non-valid index. (If you want to accept only actual boolean values, use lua_isboolean to test the value's type.)

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_type

      int lua_type(long ptr, int index)
      Wrapper of lua_type 
      
 [-0, +0, -]
 
      
 int lua_type (lua_State *L, int index);

      Returns the type of the value in the given acceptable index, or LUA_TNONE for a non-valid index (that is, an index to an "empty" stack position). The types returned by lua_type are coded by the following constants defined in lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD, and LUA_TLIGHTUSERDATA.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_yield

      int lua_yield(long ptr, int nresults)
      Wrapper of lua_yield 
      
 [-?, +?, -]
 
      
 int lua_yield  (lua_State *L, int nresults);

      Yields a coroutine.

      This function should only be called as the return expression of a C function, as follows: 

            return lua_yield (L, nresults);

      When a C function calls lua_yield in that way, the running coroutine suspends its execution, and the call to lua_resume that started this coroutine returns. The parameter nresults is the number of values from the stack that are passed as results to lua_resume.

      Parameters:
      ptr - the lua_State* pointer
      nresults - the number of results, or LUA_MULTRET
      Returns:
      see description

    • luaJ_newthread

      long luaJ_newthread(long ptr, int lid)
      A wrapper function

      Create a new thread

      Parameters:
      ptr - the lua_State* pointer
      lid - the id of the Lua state, to be used to identify between Java and Lua
      Returns:
      see description

    • luaL_newstate

      long luaL_newstate(int lid)
      Wrapper of luaL_newstate 
      
 [-0, +0, -]
 
      
 lua_State *luaL_newstate (void);

      Creates a new Lua state. It calls lua_newstate with an allocator based on the standard C realloc function and then sets a panic function (see lua_atpanic) that prints an error message to the standard error output in case of fatal errors.

      Returns the new state, or NULL if there is a memory allocation error.

      Parameters:
      lid - the id of the Lua state, to be used to identify between Java and Lua
      Returns:
      see description

    • lua_newthread

      long lua_newthread(long ptr)
      Wrapper of lua_newthread 
      
 [-0, +1, m]
 
      
 lua_State *lua_newthread (lua_State *L);

      Creates a new thread, pushes it on the stack, and returns a pointer to a lua_State that represents this new thread. The new state returned by this function shares with the original state all global objects (such as tables), but has an independent execution stack.

      There is no explicit function to close or to destroy a thread. Threads are subject to garbage collection, like any Lua object.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      see description

    • lua_tointeger

      long lua_tointeger(long ptr, int index)
      Wrapper of lua_tointeger 
      
 [-0, +0, -]
 
      
 lua_Integer lua_tointeger (lua_State *L, int index);

      Converts the Lua value at the given acceptable index to the signed integral type lua_Integer. The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tointeger returns 0.

      If the number is not an integer, it is truncated in some non-specified way.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_topointer

      long lua_topointer(long ptr, int index)
      Wrapper of lua_topointer 
      
 [-0, +0, -]
 
      
 const void *lua_topointer (lua_State *L, int index);

      Converts the value at the given acceptable index to a generic C pointer (void*). The value can be a userdata, a table, a thread, or a function; otherwise, lua_topointer returns NULL. Different objects will give different pointers. There is no way to convert the pointer back to its original value.

      Typically this function is used only for debug information.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_tothread

      long lua_tothread(long ptr, int index)
      Wrapper of lua_tothread 
      
 [-0, +0, -]
 
      
 lua_State *lua_tothread (lua_State *L, int index);

      Converts the value at the given acceptable index to a Lua thread (represented as lua_State*). This value must be a thread; otherwise, the function returns NULL.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_touserdata

      long lua_touserdata(long ptr, int index)
      Wrapper of lua_touserdata 
      
 [-0, +0, -]
 
      
 void *lua_touserdata (lua_State *L, int index);

      If the value at the given acceptable index is a full userdata, returns its block address. If the value is a light userdata, returns its pointer. Otherwise, returns NULL.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • luaJ_dumptobuffer

      Object luaJ_dumptobuffer(long ptr)
      Wrapper of lua_dump 
      
 [-0, +0, m]
 
      
 int lua_dump (lua_State *L, lua_Writer writer, void *data);

      Dumps a function as a binary chunk. Receives a Lua function on the top of the stack and produces a binary chunk that, if loaded again, results in a function equivalent to the one dumped. As it produces parts of the chunk, lua_dump calls function writer (see lua_Writer) with the given data to write them.

      The value returned is the error code returned by the last call to the writer; 0 means no errors.

      This function does not pop the Lua function from the stack.

      Parameters:
      ptr - the lua_State* pointer
      Returns:
      a nullable ByteBuffer containing the dumped binary

    • luaJ_tobuffer

      Object luaJ_tobuffer(long ptr, int index)
      Creates a ByteBuffer from the string at the specific index

      This method copies the content of the string into a buffer managed by Java, and you are safe to pop the string from Lua stack.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      a nullable ByteBuffer containing the string

    • luaJ_todirectbuffer

      Object luaJ_todirectbuffer(long ptr, int index)
      Creates a direct ByteBuffer backed by the string at the stack index

      This method creates a buffer that directly accesses the memory managed by Lua. You are not expected to modify the content of the buffer, and the buffer will become invalid after the string.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      a nullable ByteBuffer containing the string

    • luaJ_toobject

      Object luaJ_toobject(long ptr, int index)
      A wrapper function

      Convert to Java object if it is one

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_getupvalue

      String lua_getupvalue(long ptr, int funcindex, int n)
      Wrapper of lua_getupvalue 
      
 [-0, +(0|1), -]
 
      
 const char *lua_getupvalue (lua_State *L, int funcindex, int n);

      Gets information about a closure's upvalue. (For Lua functions, upvalues are the external local variables that the function uses, and that are consequently included in its closure.) lua_getupvalue gets the index n of an upvalue, pushes the upvalue's value onto the stack, and returns its name. funcindex points to the closure in the stack. (Upvalues have no particular order, as they are active through the whole function. So, they are numbered in an arbitrary order.)

      Returns NULL (and pushes nothing) when the index is greater than the number of upvalues. For C functions, this function uses the empty string "" as a name for all upvalues.

      Parameters:
      ptr - the lua_State* pointer
      funcindex - the stack position of the closure
      n - the index in the upvalue
      Returns:
      see description

    • luaL_typename

      String luaL_typename(long ptr, int index)
      Wrapper of luaL_typename 
      
 [-0, +0, -]
 
      
 const char *luaL_typename (lua_State *L, int index);

      Returns the name of the type of the value at the given index.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_setupvalue

      String lua_setupvalue(long ptr, int funcindex, int n)
      Wrapper of lua_setupvalue 
      
 [-(0|1), +0, -]
 
      
 const char *lua_setupvalue (lua_State *L, int funcindex, int n);

      Sets the value of a closure's upvalue. It assigns the value at the top of the stack to the upvalue and returns its name. It also pops the value from the stack. Parameters funcindex and n are as in the lua_getupvalue (see lua_getupvalue).

      Returns NULL (and pops nothing) when the index is greater than the number of upvalues.

      Parameters:
      ptr - the lua_State* pointer
      funcindex - the stack position of the closure
      n - the index in the upvalue
      Returns:
      see description

    • lua_tostring

      String lua_tostring(long ptr, int index)
      Wrapper of lua_tostring 
      
 [-0, +0, m]
 
      
 const char *lua_tostring (lua_State *L, int index);

      Equivalent to lua_tolstring with len equal to NULL.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      Returns:
      see description

    • lua_typename

      String lua_typename(long ptr, int tp)
      Wrapper of lua_typename 
      
 [-0, +0, -]
 
      
 const char *lua_typename  (lua_State *L, int tp);

      Returns the name of the type encoded by the value tp, which must be one the values returned by lua_type.

      Parameters:
      ptr - the lua_State* pointer
      tp - type id
      Returns:
      see description

    • lua_close

      void lua_close(long ptr)
      Wrapper of lua_close 
      
 [-0, +0, -]
 
      
 void lua_close (lua_State *L);

      Destroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by this state. On several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs, such as a daemon or a web server, might need to release states as soon as they are not needed, to avoid growing too large.

      Parameters:
      ptr - the lua_State* pointer

    • lua_concat

      void lua_concat(long ptr, int n)
      Wrapper of lua_concat 
      
 [-n, +1, e]
 
      
 void lua_concat (lua_State *L, int n);

      Concatenates the n values at the top of the stack, pops them, and leaves the result at the top. If n is 1, the result is the single value on the stack (that is, the function does nothing); if n is 0, the result is the empty string. Concatenation is performed following the usual semantics of Lua (see §2.5.4).

      Parameters:
      ptr - the lua_State* pointer
      n - the number of elements

    • lua_createtable

      void lua_createtable(long ptr, int narr, int nrec)
      Wrapper of lua_createtable 
      
 [-0, +1, m]
 
      
 void lua_createtable (lua_State *L, int narr, int nrec);

      Creates a new empty table and pushes it onto the stack. The new table has space pre-allocated for narr array elements and nrec non-array elements. This pre-allocation is useful when you know exactly how many elements the table will have. Otherwise you can use the function lua_newtable.

      Parameters:
      ptr - the lua_State* pointer
      narr - the number of pre-allocated array elements
      nrec - the number of pre-allocated non-array elements

    • lua_insert

      void lua_insert(long ptr, int index)
      Wrapper of lua_insert 
      
 [-1, +1, -]
 
      
 void lua_insert (lua_State *L, int index);

      Moves the top element into the given valid index, shifting up the elements above this index to open space. Cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • luaJ_gc

      void luaJ_gc(long ptr)
      A wrapper function

      Performs a full garbage-collection cycle

      Parameters:
      ptr - the lua_State* pointer

    • luaJ_getfield

      void luaJ_getfield(long ptr, int index, String k)
      Wrapper of lua_getfield 
      
 [-0, +1, e]
 
      
 void lua_getfield (lua_State *L, int index, const char *k);

      Pushes onto the stack the value t[k], where t is the value at the given valid index. As in Lua, this function may trigger a metamethod for the "index" event (see §2.8).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      k - the field name

    • luaJ_getglobal

      void luaJ_getglobal(long ptr, String name)
      Wrapper of lua_getglobal 
      
 [-0, +1, e]
 
      
 void lua_getglobal (lua_State *L, const char *name);

      Pushes onto the stack the value of the global name. It is defined as a macro: 

            #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)
      Parameters:
      ptr - the lua_State* pointer
      name - the name

    • luaJ_getmetatable

      void luaJ_getmetatable(long ptr, String tname)
      Wrapper of luaL_getmetatable 
      
 [-0, +1, -]
 
      
 void luaL_getmetatable (lua_State *L, const char *tname);

      Pushes onto the stack the metatable associated with name tname in the registry (see luaL_newmetatable).

      Parameters:
      ptr - the lua_State* pointer
      tname - type name

    • luaJ_gettable

      void luaJ_gettable(long ptr, int index)
      Wrapper of lua_gettable 
      
 [-1, +1, e]
 
      
 void lua_gettable (lua_State *L, int index);

      Pushes onto the stack the value t[k], where t is the value at the given valid index and k is the value at the top of the stack.

      This function pops the key from the stack (putting the resulting value in its place). As in Lua, this function may trigger a metamethod for the "index" event (see §2.8).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • luaJ_openlib

      void luaJ_openlib(long ptr, String lib)
      A wrapper function

      Open a library indivisually, alternative to luaL_openlibs

      Parameters:
      ptr - the lua_State* pointer
      lib - library name

    • luaJ_pusharray

      void luaJ_pusharray(long ptr, Object array)
      A wrapper function

      Push a Java array

      Parameters:
      ptr - the lua_State* pointer
      array - the Java array

    • luaJ_pushclass

      void luaJ_pushclass(long ptr, Object clazz)
      A wrapper function

      Push a Java class

      Parameters:
      ptr - the lua_State* pointer
      clazz - the Java class

    • luaJ_pushfunction

      void luaJ_pushfunction(long ptr, Object func)
      A wrapper function

      Push a JFunction

      Parameters:
      ptr - the lua_State* pointer
      func - the function object

    • luaJ_pushlstring

      void luaJ_pushlstring(long ptr, Buffer buffer, int start, int size)
      A wrapper function

      Push a buffer as a raw Lua string

      Parameters:
      ptr - the lua_State* pointer
      buffer - the buffer (expecting direct)
      start - the starting index
      size - size

    • luaJ_pushobject

      void luaJ_pushobject(long ptr, Object obj)
      A wrapper function

      Push a Java object

      Parameters:
      ptr - the lua_State* pointer
      obj - the Java object

    • luaJ_pushstring

      void luaJ_pushstring(long ptr, String s)
      Wrapper of lua_pushstring 
      
 [-0, +1, m]
 
      
 void lua_pushstring (lua_State *L, const char *s);

      Pushes the zero-terminated string pointed to by s onto the stack. Lua makes (or reuses) an internal copy of the given string, so the memory at s can be freed or reused immediately after the function returns. The string cannot contain embedded zeros; it is assumed to end at the first zero.

      Parameters:
      ptr - the lua_State* pointer
      s - the string

    • luaJ_rawget

      void luaJ_rawget(long ptr, int index)
      Wrapper of lua_rawget 
      
 [-1, +1, -]
 
      
 void lua_rawget (lua_State *L, int index);

      Similar to lua_gettable, but does a raw access (i.e., without metamethods).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • luaJ_rawgeti

      void luaJ_rawgeti(long ptr, int index, int n)
      Wrapper of lua_rawgeti 
      
 [-0, +1, -]
 
      
 void lua_rawgeti (lua_State *L, int index, int n);

      Pushes onto the stack the value t[n], where t is the value at the given valid index. The access is raw; that is, it does not invoke metamethods.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      n - the number of elements

    • luaJ_removestateindex

      void luaJ_removestateindex(long ptr)
      A wrapper function

      Removes the thread from the global registry, thus allowing it to get garbage collected

      Parameters:
      ptr - the lua_State* pointer

    • luaJ_setmetatable

      void luaJ_setmetatable(long ptr, int index)
      Wrapper of lua_setmetatable 
      
 [-1, +0, -]
 
      
 int lua_setmetatable (lua_State *L, int index);

      Pops a table from the stack and sets it as the new metatable for the value at the given acceptable index.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • luaL_openlibs

      void luaL_openlibs(long ptr)
      Wrapper of luaL_openlibs 
      
 [-0, +0, m]
 
      
 void luaL_openlibs (lua_State *L);

      Opens all standard Lua libraries into the given state.

      Parameters:
      ptr - the lua_State* pointer

    • luaL_unref

      void luaL_unref(long ptr, int t, int ref)
      Wrapper of luaL_unref 
      
 [-0, +0, -]
 
      
 void luaL_unref (lua_State *L, int t, int ref);

      Releases reference ref from the table at index t (see luaL_ref). The entry is removed from the table, so that the referred object can be collected. The reference ref is also freed to be used again.

      If ref is LUA_NOREF or LUA_REFNIL, luaL_unref does nothing.

      Parameters:
      ptr - the lua_State* pointer
      t - the stack index
      ref - the reference

    • luaL_where

      void luaL_where(long ptr, int lvl)
      Wrapper of luaL_where 
      
 [-0, +1, m]
 
      
 void luaL_where (lua_State *L, int lvl);

      Pushes onto the stack a string identifying the current position of the control at level lvl in the call stack. Typically this string has the following format: 

            chunkname:currentline:

      Level 0 is the running function, level 1 is the function that called the running function, etc.

      This function is used to build a prefix for error messages.

      Parameters:
      ptr - the lua_State* pointer
      lvl - the running level

    • lua_newtable

      void lua_newtable(long ptr)
      Wrapper of lua_newtable 
      
 [-0, +1, m]
 
      
 void lua_newtable (lua_State *L);

      Creates a new empty table and pushes it onto the stack. It is equivalent to lua_createtable(L, 0, 0).

      Parameters:
      ptr - the lua_State* pointer

    • lua_pop

      void lua_pop(long ptr, int n)
      Wrapper of lua_pop 
      
 [-n, +0, -]
 
      
 void lua_pop (lua_State *L, int n);

      Pops n elements from the stack.

      Parameters:
      ptr - the lua_State* pointer
      n - the number of elements

    • lua_pushboolean

      void lua_pushboolean(long ptr, int b)
      Wrapper of lua_pushboolean 
      
 [-0, +1, -]
 
      
 void lua_pushboolean (lua_State *L, int b);

      Pushes a boolean value with value b onto the stack.

      Parameters:
      ptr - the lua_State* pointer
      b - boolean

    • lua_pushinteger

      void lua_pushinteger(long ptr, long n)
      Wrapper of lua_pushinteger 
      
 [-0, +1, -]
 
      
 void lua_pushinteger (lua_State *L, lua_Integer n);

      Pushes a number with value n onto the stack.

      Parameters:
      ptr - the lua_State* pointer
      n - integer

    • lua_pushlightuserdata

      void lua_pushlightuserdata(long ptr, long p)
      Wrapper of lua_pushlightuserdata 
      
 [-0, +1, -]
 
      
 void lua_pushlightuserdata (lua_State *L, void *p);

      Pushes a light userdata onto the stack.

      Userdata represent C values in Lua. A light userdata represents a pointer. It is a value (like a number): you do not create it, it has no individual metatable, and it is not collected (as it was never created). A light userdata is equal to "any" light userdata with the same C address.

      Parameters:
      ptr - the lua_State* pointer
      p - the pointer

    • lua_pushnil

      void lua_pushnil(long ptr)
      Wrapper of lua_pushnil 
      
 [-0, +1, -]
 
      
 void lua_pushnil (lua_State *L);

      Pushes a nil value onto the stack.

      Parameters:
      ptr - the lua_State* pointer

    • lua_pushnumber

      void lua_pushnumber(long ptr, double n)
      Wrapper of lua_pushnumber 
      
 [-0, +1, -]
 
      
 void lua_pushnumber (lua_State *L, lua_Number n);

      Pushes a number with value n onto the stack.

      Parameters:
      ptr - the lua_State* pointer
      n - the number of elements

    • lua_pushvalue

      void lua_pushvalue(long ptr, int index)
      Wrapper of lua_pushvalue 
      
 [-0, +1, -]
 
      
 void lua_pushvalue (lua_State *L, int index);

      Pushes a copy of the element at the given valid index onto the stack.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_rawset

      void lua_rawset(long ptr, int index)
      Wrapper of lua_rawset 
      
 [-2, +0, m]
 
      
 void lua_rawset (lua_State *L, int index);

      Similar to lua_settable, but does a raw assignment (i.e., without metamethods).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_rawseti

      void lua_rawseti(long ptr, int index, int i)
      Wrapper of lua_rawseti 
      
 [-1, +0, m]
 
      
 void lua_rawseti (lua_State *L, int index, int n);

      Does the equivalent of t[n] = v, where t is the value at the given valid index and v is the value at the top of the stack.

      This function pops the value from the stack. The assignment is raw; that is, it does not invoke metamethods.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      i - the index

    • lua_remove

      void lua_remove(long ptr, int index)
      Wrapper of lua_remove 
      
 [-1, +0, -]
 
      
 void lua_remove (lua_State *L, int index);

      Removes the element at the given valid index, shifting down the elements above this index to fill the gap. Cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_replace

      void lua_replace(long ptr, int index)
      Wrapper of lua_replace 
      
 [-1, +0, -]
 
      
 void lua_replace (lua_State *L, int index);

      Moves the top element into the given position (and pops it), without shifting any element (therefore replacing the value at the given position).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_setfield

      void lua_setfield(long ptr, int index, String k)
      Wrapper of lua_setfield 
      
 [-1, +0, e]
 
      
 void lua_setfield (lua_State *L, int index, const char *k);

      Does the equivalent to t[k] = v, where t is the value at the given valid index and v is the value at the top of the stack.

      This function pops the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.8).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element
      k - the field name

    • lua_setglobal

      void lua_setglobal(long ptr, String name)
      Wrapper of lua_setglobal 
      
 [-1, +0, e]
 
      
 void lua_setglobal (lua_State *L, const char *name);

      Pops a value from the stack and sets it as the new value of global name. It is defined as a macro: 

            #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)
      Parameters:
      ptr - the lua_State* pointer
      name - the name

    • lua_settable

      void lua_settable(long ptr, int index)
      Wrapper of lua_settable 
      
 [-2, +0, e]
 
      
 void lua_settable (lua_State *L, int index);

      Does the equivalent to t[k] = v, where t is the value at the given valid index, v is the value at the top of the stack, and k is the value just below the top.

      This function pops both the key and the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.8).

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_settop

      void lua_settop(long ptr, int index)
      Wrapper of lua_settop 
      
 [-?, +?, -]
 
      
 void lua_settop (lua_State *L, int index);

      Accepts any acceptable index, or 0, and sets the stack top to this index. If the new top is larger than the old one, then the new elements are filled with nil. If index is 0, then all stack elements are removed.

      Parameters:
      ptr - the lua_State* pointer
      index - the stack position of the element

    • lua_xmove

      void lua_xmove(long from, long to, int n)
      Wrapper of lua_xmove 
      
 [-?, +?, -]
 
      
 void lua_xmove (lua_State *from, lua_State *to, int n);

      Exchange values between different threads of the same global state.

      This function pops n values from the stack from, and pushes them onto the stack to.

      Parameters:
      from - a thread
      to - another thread
      n - the number of elements