- * If an error happens outside any protected environment, Lua calls a
- * panic function and then calls exit(EXIT_FAILURE),
- * thus exiting the host application. Your panic function may avoid this
- * exit by never returning (e.g., doing a long jump).
- *
- *
- *
- * The panic function can access the error message at the top of the stack. - */ - public LFunction atpanic(LFunction panicf) { - LFunction f = panic; - panic = panicf; - return f; - } - /** * Returns the current program counter for the given call frame. * @param ci -- A call frame @@ -1092,176 +1067,12 @@ public class LuaState extends Lua { } /** - * Raises an error with the default level. + * Raises an error with the default level. */ public void error(String message) { throw new LuaErrorException( this, message, 1 ); } - - /** - * Generates a Lua error. [-1, +0, v] - * - *
- * 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).
- *
- */
- public void error() {
- throw new LuaErrorException( this, tostring(-1), 0);
- }
-
- /**
- * Dumps a function as a binary chunk. [-0, +0,
- * m]
- *
- *
- * 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. - * - */ - public void dump() { - notImplemented(); - } - - /** - * Pushes a new C closure onto the stack. [-n, +1, - * m] - * - * - *
- * When a Java function is created, it is possible to associate some
- * values with it, thus creating a C closure (see §3.4); these values are then accessible to the
- * function whenever it is called. To associate values with a
- * C function, first these values should be pushed onto the stack (when
- * there are multiple values, the first value is pushed first). Then lua_pushcclosure is called
- * to create and push the C function onto the stack, with the argument
- * n telling how many values should be associated with the
- * function. lua_pushcclosure
- * also pops these values from the stack.
- */
- public void pushclosure(LFunction fn, int n) {
- notImplemented();
- }
-
- /**
- * Calls the C function func in protected mode. [-0, +(0|1), -]
- *
- *
- * func starts with only one element in its stack, a light
- * userdata containing ud. In case of errors, lua_cpcall returns the same error
- * codes as lua_pcall, plus the
- * error object on the top of the stack; otherwise, it returns zero, and
- * does not change the stack. All values returned by func are
- * discarded.
- */
- public int javapcall(LFunction func, Object ud) {
- this.pushjavafunction(func);
- this.pushlightuserdata(ud);
- return this.pcall(1, 0, 0);
- }
-
- /**
- * Format and push a string. [-0, +1, m]
- *
- *
- * Pushes onto the stack a formatted string and returns a pointer to this
- * string. It is similar to the C function sprintf, but
- * has some important differences:
- *
- *
%%'
- * (inserts a '%' in the string), '%s'
- * (inserts a zero-terminated string, with no size restrictions), '%f'
- * (inserts a lua_Number), '%p'
- * (inserts a pointer as a hexadecimal numeral), '%d'
- * (inserts an int), and '%c' (inserts an
- * int as a character).
- * Equivalent to lua_pushfstring,
- * except that it receives a va_list instead of a variable
- * number of arguments.
- */
- public void pushvfstring(String format, Object[] args) {
- notImplemented();
- }
-
- /**
- * Test if two objects are the same object. [-0, +0,
- * -]
- *
- *
- * 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.
- */
- public void rawequal(int index1, int index2) {
- notImplemented();
- }
-
- /**
- * Pushes a value's environment table. [-0, +1,
- * -]
- *
- *
- * Pushes onto the stack the environment table of the value at the given - * index. - */ - public void getfenv(int index) { - LValue f = topointer(index); - pushlvalue( ((LClosure) f).env ); - } - - /** - * Set the environment for a value. [-1, +0, -] - * - *
- * Pops a table from the stack and sets it as the new environment for the
- * value at the given index. If the value at the given index is neither a
- * function nor a thread nor a userdata, lua_setfenv
- * returns false. Otherwise it returns true.
- */
- public boolean setfenv(int index) {
- LTable t = totable(-1);
- LValue f = topointer(index);
- pop(1);
- return f.luaSetEnv(t);
- }
-
-
/**
*
* Ensures that there are at least extra free stack slots in
@@ -1282,125 +1093,6 @@ public class LuaState extends Lua {
}
}
-
- /**
- * Closes the given Lua state. [-0, +0, -]
- *
- *
- * 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.
- */
- public void close() {
- stack = new LValue[20];
- base = top = 0;
- }
-
- /**
- * Concatenates the n values at the top of the stack. [-n, +1, e]
- *
- *
- * 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).
- */
- public void concat(int n) {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- for ( int i=-n; i<0; i++ ) {
- LString ls = tolstring(i);
- baos.write(ls.m_bytes, ls.m_offset, ls.m_length);
- }
- pop(n);
- pushlvalue( new LString(baos.toByteArray()));
- }
-
- /**
- * Creates a new empty table and pushes it onto the stack. [-0, +1, m]
- *
- *
- * 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.
- */
- public void createtable(int narr, int nrec) {
- pushlvalue( new LTable(narr, nrec) );
- }
-
- /**
- * Tests if two items on the stack are equal. [-0, +0,
- * e]
- *
- *
- * Returns 1 if the two values in acceptable indices index1
- * and index2 are equal, following the semantics of the Lua
- * == operator (that is, may call metamethods). Otherwise
- * returns 0. Also returns 0 if any of the indices is non valid.
- *
- *
- */
- public boolean equal(int index1, int index2) {
- return topointer(index2).luaBinOpUnknown(Lua.OP_EQ,
- topointer(index1)).toJavaBoolean();
- }
-
- /**
- * Controls the garbage collector. [-0, +0, e]
- *
- *
- * This function performs several tasks, according to the value of the
- * parameter what:
- *
- *
LUA_GCSTOP: stops the garbage collector.
- * LUA_GCRESTART: restarts the garbage
- * collector. LUA_GCCOLLECT: performs a full
- * garbage-collection cycle. LUA_GCCOUNT: returns the current amount of
- * memory (in Kbytes) in use by Lua. LUA_GCCOUNTB: returns the remainder of
- * dividing the current amount of bytes of memory in use by Lua by 1024.
- * LUA_GCSTEP: performs an incremental step of
- * garbage collection. The step "size" is controlled by data
- * (larger values mean more steps) in a non-specified way. If you want to
- * control the step size you must experimentally tune the value of
- * data. The function returns 1 if the step finished a
- * garbage-collection cycle. LUA_GCSETPAUSE: sets data/100
- * as the new value for the pause of the collector (see §2.10). The function returns the previous value of
- * the pause. LUA_GCSETSTEPMUL: sets data/100
- * as the new value for the step multiplier of the collector (see
- * §2.10). The function returns the previous value
- * of the step multiplier.
- * 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). - */ - public void gettable(int index) { - LValue t = totable(index); - LValue k = poplvalue(); - pushlvalue( this.luaV_gettable(t, k) ); - } - /** * Insert the top item somewhere in the stack. [-1, +1, * -] @@ -1511,29 +1183,6 @@ public class LuaState extends Lua { return type(index) == Lua.LUA_TFUNCTION; } - /** - * Test if a value is a JavaFunction. [-0, +0, -] - * - *
- * Returns 1 if the value at the given acceptable index is a - * C function, and 0 otherwise. - * - */ - public boolean isjavafunction(int index) { - return topointer(index) instanceof LFunction; - } - - /** - * Test if a value is light user data [-0, +0, -] - * - *
- * Returns 1 if the value at the given acceptable index is a light userdata, - * and 0 otherwise. - */ - public boolean islightuserdata(int index) { - return false; - } - /** * Test if a value is nil [-0, +0, -] * @@ -1545,17 +1194,6 @@ public class LuaState extends Lua { return topointer(index).isNil(); } - /** - * Test if a value is not valid [-0, +0, -] - * - *
- * Returns 1 if the the given acceptable index is not valid (that is, it - * refers to an element outside the current stack), and 0 otherwise. - */ - public boolean isnone(int index) { - return topointer(index) == null; - } - /** * Test if a value is nil or not valid [-0, +0, * -] @@ -1636,136 +1274,6 @@ public class LuaState extends Lua { return type(index) == Lua.LUA_TUSERDATA; } - /** - * Compare two values [-0, +0, e] - * - *
- * Returns 1 if the value at acceptable index index1 is
- * smaller than the value at acceptable index index2,
- * following the semantics of the Lua < operator (that is,
- * may call metamethods). Otherwise returns 0. Also returns 0 if
- * any of the indices is non valid.
- */
- public boolean lessthan(int index1, int index2) {
- return topointer(index2).luaBinOpUnknown(Lua.OP_LT,
- topointer(index1)).toJavaBoolean();
- }
-
- /**
- * Create a table [-0, +1, m]
- *
- *
- * Creates a new empty table and pushes it onto the stack. It is equivalent
- * to lua_createtable(L, 0, 0).
- */
- public void newtable() {
- pushlvalue( new LTable() );
- }
-
- /**
- * Create a thread [-0, +1, m]
- *
- *
- * 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. - */ - public void newthread() { - notImplemented(); - } - - /** - * Create a userdata [-0, +1, m] - * - *
- * This function allocates a new block of memory with the given size, pushes - * onto the stack a new full userdata with the block address, and returns - * this address. - * - * - *
- * Userdata represent C values in Lua. A full userdata - * represents a block of memory. It is an object (like a table): you must - * create it, it can have its own metatable, and you can detect when it is - * being collected. A full userdata is only equal to itself (under raw - * equality). - * - * - *
- * When Lua collects a full userdata with a gc metamethod,
- * Lua calls the metamethod and marks the userdata as finalized. When this
- * userdata is collected again then Lua frees its corresponding memory.
- */
- public void newuserdata(Object o) {
- pushlvalue( new LUserData(o) );
- }
-
- /**
- * Traverse to the next table item. [-1, +(2|0),
- * e]
- *
- *
- * 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.
- */
- public int next(int index) {
- notImplemented();
- return 0;
- }
-
- /**
- * Get the length of an object [-0, +0, -]
- *
- *
- * Returns the "length" of the value at the given acceptable index: for
- * strings, this is the string length; for tables, this is the result of the
- * length operator ('
- * This function receives a pointer to a C function and pushes onto the
+ * This function receives an LFunction and pushes onto the
* stack a Lua value of type
* Any function to be registered in Lua must follow the correct protocol to
- * receive its parameters and return its results (see
- * 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.
- */
- public void pushlightuserdata(Object p) {
- notImplemented();
- }
-
/**
* Push an LString onto the stack. [-0, +1,
@@ -1917,16 +1408,6 @@ public class LuaState extends Lua {
else
pushlstring( LString.valueOf(s) );
}
-
- /**
- * Push a thread onto the stack. [-0, +1, -]
- *
- * Pushes the thread represented by
- * Similar to
- * Similar to
- * Does the equivalent of
- * This function pops the value from the stack. The assignment is raw; that
- * is, it does not invoke metamethods.
- */
- public void rawseti(int index, int n) {
- LTable t = totable(index);
- LValue v = poplvalue();
- t.put(n,v);
- }
-
- /**
- * Register a LFunction with a specific name. [-0, +0,
- * m]
- *
- *
- * Sets the function
- * To start a coroutine, you first create a new thread (see
- * Pops a table from the stack and sets it as the new metatable for the
- * value at the given acceptable index.
- */
- public void setmetatable(int index) {
- LTable t = totable(index);
- LValue v = poplvalue();
- LValue n = t.luaSetMetatable(v);
- if ( n != null ) {
- pushlvalue(n);
- replace(index);
- }
- }
-
- /**
- * Set the value of a table for a key. [-2, +0,
- * e]
- *
- *
- * Does the equivalent to
- * 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).
- */
- public void settable(int index) {
- LTable t = totable(index);
- LValue v = poplvalue();
- LValue k = poplvalue();
- this.luaV_settable(t, k, v);
- }
-
- /**
- * Returns the status of the thread
- * The status can be 0 for a normal thread, an error code if the thread
- * finished its execution with an error, or
- * Converts the value at the given acceptable index to a Lua thread
- * (represented as
* [-0, +0, -]
*
*
* Converts a value at the given acceptable index to a C function. That
- * value must be a C function; otherwise, returns
- * This function should only be called as the return expression of a
- * C function, as follows:
- *
- *
- * When a C function calls #'); for userdata, this is the size of
- * the block of memory allocated for the userdata; for other values, it
- * is 0.
- */
- public int objlen(int index) {
- LValue p = topointer( index );
- switch ( p.luaGetType() ) {
- case LUA_TTABLE:
- case LUA_TSTRING:
- return p.luaLength();
- default:
- return 0;
- }
- }
-
/**
* Pops n elements from the stack. [-n,
* +0, -]
@@ -1817,41 +1325,24 @@ public class LuaState extends Lua {
}
/**
- * Pushes a Java function onto the stack. [-0, +1,
+ * Pushes a function onto the stack. [-0, +1,
* m]
*
* function that, when called,
- * invokes the corresponding C function.
+ * invokes the corresponding function.
*
*
* lua_CFunction).
- *
+ * receive its parameters and return its results
+ * @see LFunction
*/
- public void pushjavafunction(LFunction f) {
+ public void pushfunction(LFunction f) {
pushlvalue( f );
}
- /**
- * Pushes a light userdata onto the stack. [-0, +1,
- * -]
- *
- *
- * L onto the stack. Returns
- * 1 if this thread is the main thread of its state.
- */
- public void pushthread() {
- notImplemented();
- }
/**
* Push a value from the stack onto the stack. [-0, +1,
@@ -1939,18 +1420,6 @@ public class LuaState extends Lua {
pushlvalue(topointer(index));
}
- /**
- * Do a table get without metadata calls. [-1, +1,
- * -]
- *
- * lua_gettable, but
- * does a raw access (i.e., without metamethods).
- */
- public void rawget(int index) {
- pushlvalue( totable(index).get(poplvalue()) );
- }
-
/**
* Do a integer-key table get without metadata calls. [-0, +1, -]
@@ -1959,65 +1428,12 @@ public class LuaState extends Lua {
* 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.
+ * @deprecated should get the table and do a raw get instead
*/
public void rawgeti(int index, int n) {
pushlvalue( totable(index).get(n) );
}
- /**
- * Do a table set without metadata calls. [-2, +0,
- * m]
- *
- * lua_settable, but
- * does a raw assignment (i.e., without metamethods).
- */
- public void rawset(int index) {
- LTable t = totable(index);
- LValue v = poplvalue();
- LValue k = poplvalue();
- t.put(k,v);
- }
-
- /**
- * Do a integer-key table set without metadata calls. [-1, +0, m]
- *
- * t[n] = v, where t
- * is the value at the given valid index and v is the value
- * at the top of the stack.
- *
- *
- * f as the new value of global
- * name. It is defined as a macro:
- *
- *
- * #define lua_register(L,n,f) \
- * (lua_pushcfunction(L, f), lua_setglobal(L, n))
- *
- *
- */
- public void register(String name, LFunction f) {
- pushjavafunction(f);
- setglobal(name);
- }
-
/**
* Remove an element from the stack. [-1, +0, -]
*
@@ -2045,32 +1461,6 @@ public class LuaState extends Lua {
stack[ai] = poplvalue();
}
- /**
- * Starts and resumes a coroutine in a given thread. [-?,
- * +?, -]
- *
- *
- * lua_newthread); then you push
- * onto its stack the main function plus any arguments; then you call lua_resume, with
- * narg being the number of arguments. This call returns when
- * the coroutine suspends or finishes its execution. When it returns, the
- * stack contains all values passed to lua_yield,
- * or all values returned by the body function. lua_resume
- * returns LUA_YIELD if the
- * coroutine yields, 0 if the coroutine finishes its execution without
- * errors, or an error code in case of errors (see lua_pcall).
- * In case of errors, the stack is not unwound, so you can use the debug API
- * over it. The error message is on the top of the stack. To restart a
- * coroutine, you put on its stack only the values to be passed as results
- * from yield, and then call lua_resume.
- */
- public void resume(int narg) {
- notImplemented();
- }
-
/**
* Set the value of a table field. [-1, +0, e]
*
@@ -2107,75 +1497,6 @@ public class LuaState extends Lua {
this.luaV_settable(_G, new LString(name), poplvalue());
}
- /**
- * Set the metatable of a value. [-1, +0, -]
- *
- * 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.
- *
- *
- * L. [-0, +0, -]
- *
- *
- *
- * LUA_YIELD
- * if the thread is suspended.
- *
- */
- public void status() {
- notImplemented();
- }
-
- /**
- * Get a thread value from the stack. [-0, +0, -]
- *
- * lua_State*). This value must be a thread;
- * otherwise, the function returns NULL.
- */
- public LuaState tothread(int index) {
- notImplemented();
- return null;
- }
-
/**
* Get a value as a boolean. [-0, +0, -]
*
@@ -2214,22 +1535,23 @@ public class LuaState extends Lua {
}
/**
- * Get a value as a JavaFunction.
+ * Get a value as a LFunction.
*
- *
+ * lua_tocfunction
* tofunction
- * lua_CFunction lua_tocfunction (lua_State *L, int index);
+ * LFunction tofunction (lua_State *L, int index);
*
*
* NULL.
+ * value must be a function; otherwise, returns NULL.
*/
- public LFunction tojavafunction(int index) {
- return (LFunction) topointer(index);
+ public LValue tofunction(int index) {
+ LValue v = topointer(index);
+ return v.isFunction()? v: LNil.NIL;
}
/**
@@ -2434,31 +1756,6 @@ public class LuaState extends Lua {
ss.top += n;
}
}
-
- /**
- * Yields a coroutine. [-?, +?, -]
- *
- *
- *
- * return lua_yield(L, nresults);
- *
- *
- * 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.
- *
- */
- public void yield(int nresults) {
- notImplemented();
- }
// ============================= conversion to and from Java boxed types ====================
@@ -2558,7 +1855,7 @@ public class LuaState extends Lua {
if ( o == null )
pushnil();
else
- newuserdata( o );
+ pushlvalue( new LUserData(o) );
}
diff --git a/src/j2se/org/luaj/lib/j2se/LuajavaLib.java b/src/j2se/org/luaj/lib/j2se/LuajavaLib.java
index 9d0b1fdf..bac9d6a0 100644
--- a/src/j2se/org/luaj/lib/j2se/LuajavaLib.java
+++ b/src/j2se/org/luaj/lib/j2se/LuajavaLib.java
@@ -126,7 +126,7 @@ public final class LuajavaLib extends LFunction {
final int ninterfaces = Math.max(0,vm.gettop()-2);
if ( ninterfaces <= 0 )
throw new LuaErrorException("no interfaces");
- final LValue function = vm.tojavafunction(-1);
+ final LValue function = vm.tofunction(-1);
try {
// get the interfaces
final Class[] ifaces = new Class[ninterfaces];
diff --git a/src/test/java/org/luaj/vm/LuaStateTest.java b/src/test/java/org/luaj/vm/LuaStateTest.java
index 8fba15fd..3cc33910 100644
--- a/src/test/java/org/luaj/vm/LuaStateTest.java
+++ b/src/test/java/org/luaj/vm/LuaStateTest.java
@@ -25,7 +25,7 @@ public class LuaStateTest extends TestCase {
public void testFuncCall() throws IOException {
vm.pushstring("bogus");
- vm.pushjavafunction(new SomeFunc( "arg" ));
+ vm.pushfunction(new SomeFunc( "arg" ));
vm.pushstring("arg");
vm.call(1, 1);
assertEquals( 2, vm.gettop() );
@@ -36,7 +36,7 @@ public class LuaStateTest extends TestCase {
public void testFuncCall2() throws IOException {
vm.pushstring("bogus");
- vm.pushjavafunction(new SomeFunc( "nil" ));
+ vm.pushfunction(new SomeFunc( "nil" ));
vm.call(0, 1);
assertEquals( 2, vm.gettop() );
assertEquals( "bogus", vm.tostring(1) );
diff --git a/version.properties b/version.properties
index e0e4f2bb..05bc6ae8 100644
--- a/version.properties
+++ b/version.properties
@@ -1 +1 @@
-version: 0.42
+version: 0.43