org.luaj.vm2.LuaClosure Java Examples

@Test
public void testLuaFunction() {
    final Globals theGlobals = new Globals();
    LuaC.install(theGlobals);
    final LuaValue chunk = theGlobals.load("function add(a,b)\nreturn a+b\nend\nreturn add(1,2)");
    Assert.assertFalse(chunk.isnil());
    Assert.assertTrue(chunk instanceof LuaClosure);
    final LuaClosure luaClosure = (LuaClosure) chunk;
    final LuaString theResult = luaClosure.call().strvalue();
    Assert.assertEquals("3", theResult.tojstring());
}
 

static LuaString findupvalue(LuaClosure c, int up) {
	if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
		if ( c.p.upvalues != null && up <= c.p.upvalues.length )
			return c.p.upvalues[up-1].name;
		else
			return LuaString.valueOf( "."+up );
	}
	return null;
}
 

public LuaValue call(LuaValue arg) {
	LuaValue f = arg.checkfunction();
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try {
		DumpState.dump( ((LuaClosure)f).p, baos, true );
		return LuaString.valueUsing(baos.toByteArray());
	} catch (IOException e) {
		return error( e.getMessage() );
	}
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			return varargsOf(name, c.upValues[up-1].getValue() );
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	LuaValue value = args.arg(3);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			c.upValues[up-1].setValue(value);
			return name;
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
			return valueOf(c.upValues[up-1].hashCode());
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaClosure f1 = args.checkclosure(1);
	int n1 = args.checkint(2);
	LuaClosure f2 = args.checkclosure(3);
	int n2 = args.checkint(4);
	if (n1 < 1 || n1 > f1.upValues.length)
		argerror("index out of range");
	if (n2 < 1 || n2 > f2.upValues.length)
		argerror("index out of range");
	f1.upValues[n1-1] = f2.upValues[n2-1];
	return NONE;
}
 

static LuaString findupvalue(LuaClosure c, int up) {
	if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
		if ( c.p.upvalues != null && up <= c.p.upvalues.length )
			return c.p.upvalues[up-1].name;
		else
			return LuaString.valueOf( "."+up );
	}
	return null;
}
 

public LuaValue call(LuaValue arg) {
	LuaValue f = arg.checkfunction();
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try {
		DumpState.dump( ((LuaClosure)f).p, baos, true );
		return LuaString.valueUsing(baos.toByteArray());
	} catch (IOException e) {
		return error( e.getMessage() );
	}
}
 

public Varargs invoke(Varargs args) {
    LuaValue func = args.checkfunction(1);
    int up = args.checkint(2);
    if (func instanceof LuaClosure) {
        LuaClosure c = (LuaClosure) func;
        LuaString name = findupvalue(c, up);
        if (name != null) {
            return varargsOf(name, c.upValues[up - 1].getValue());
        }
    }
    return NIL;
}
 

@Test
public void testCall() throws IOException {
    final Globals theGlobals = new Globals();
    LuaC.install(theGlobals);
    final Prototype thePrototype = theGlobals.compilePrototype(new StringReader("function add(a,b) return a + b end"), "script");
    new LuaClosure(thePrototype, theGlobals).call();
    final LuaValue theFunction = theGlobals.get("add");
    Assert.assertFalse(theFunction.isnil());
    final Varargs theArguments = LuaValue.varargsOf(new LuaValue[] {
            LuaInteger.valueOf(100),
            LuaInteger.valueOf(200)
    });
    final LuaInteger theResult = (LuaInteger) theFunction.invoke(theArguments);
    Assert.assertEquals("300", theResult.tojstring());
}
 

@Test
public void testCallStringResult() throws IOException {
    final Globals theGlobals = new Globals();
    LuaC.install(theGlobals);
    final Prototype thePrototype = theGlobals.compilePrototype(new StringReader("function add(a,b) return 'hello' end"), "script");
    new LuaClosure(thePrototype, theGlobals).call();
    final Varargs theArguments = LuaValue.varargsOf(new LuaValue[] {
            LuaInteger.valueOf(100),
            LuaInteger.valueOf(200)
    });
    final LuaValue theFunction = theGlobals.get("add");
    final LuaValue theValue = (LuaValue) theFunction.invoke(theArguments);
    Assert.assertTrue(theValue.isstring());
    Assert.assertEquals("hello", theValue.tojstring());
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			return varargsOf(name, c.upValues[up-1].getValue() );
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	LuaValue value = args.arg(3);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			c.upValues[up-1].setValue(value);
			return name;
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
			return valueOf(c.upValues[up-1].hashCode());
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaClosure f1 = args.checkclosure(1);
	int n1 = args.checkint(2);
	LuaClosure f2 = args.checkclosure(3);
	int n2 = args.checkint(4);
	if (n1 < 1 || n1 > f1.upValues.length)
		argerror("index out of range");
	if (n2 < 1 || n2 > f2.upValues.length)
		argerror("index out of range");
	f1.upValues[n1-1] = f2.upValues[n2-1];
	return NONE;
}
 

static LuaString findupvalue(LuaClosure c, int up) {
	if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
		if ( c.p.upvalues != null && up <= c.p.upvalues.length )
			return c.p.upvalues[up-1].name;
		else
			return LuaString.valueOf( "."+up );
	}
	return null;
}
 

public Varargs invoke(Varargs args) {
	LuaValue f = args.checkfunction(1);
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try {
		DumpState.dump( ((LuaClosure)f).p, baos, args.optboolean(2, true) );
		return LuaString.valueUsing(baos.toByteArray());
	} catch (IOException e) {
		return error( e.getMessage() );
	}
}
 

public Varargs invoke(Varargs args) {
    LuaValue func = args.checkfunction(1);
    int up = args.checkint(2);
    LuaValue value = args.arg(3);
    if (func instanceof LuaClosure) {
        LuaClosure c = (LuaClosure) func;
        LuaString name = findupvalue(c, up);
        if (name != null) {
            c.upValues[up - 1].setValue(value);
            return name;
        }
    }
    return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaClosure f1 = args.checkclosure(1);
	int n1 = args.checkint(2);
	LuaClosure f2 = args.checkclosure(3);
	int n2 = args.checkint(4);
	if (n1 < 1 || n1 > f1.upValues.length)
		argerror("index out of range");
	if (n2 < 1 || n2 > f2.upValues.length)
		argerror("index out of range");
	f1.upValues[n1-1] = f2.upValues[n2-1];
	return NONE;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		if ( c.upValues != null && up > 0 && up <= c.upValues.length ) {
			return valueOf(c.upValues[up-1].hashCode());
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	LuaValue value = args.arg(3);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			c.upValues[up-1].setValue(value);
			return name;
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
	LuaValue func = args.checkfunction(1);
	int up = args.checkint(2);
	if ( func instanceof LuaClosure ) {
		LuaClosure c = (LuaClosure) func;
		LuaString name = findupvalue(c, up);
		if ( name != null ) {
			return varargsOf(name, c.upValues[up-1].getValue() );
		}
	}
	return NIL;
}
 

public Varargs invoke(Varargs args) {
    LuaValue func = args.checkfunction(1);
    int up = args.checkint(2);
    if (func instanceof LuaClosure) {
        LuaClosure c = (LuaClosure) func;
        if (c.upValues != null && up > 0 && up <= c.upValues.length) {
            return valueOf(c.upValues[up - 1].hashCode());
        }
    }
    return NIL;
}
 

public Varargs invoke(Varargs args) {
    LuaClosure f1 = args.checkclosure(1);
    int n1 = args.checkint(2);
    LuaClosure f2 = args.checkclosure(3);
    int n2 = args.checkint(4);
    if (n1 < 1 || n1 > f1.upValues.length)
        argerror("index out of range");
    if (n2 < 1 || n2 > f2.upValues.length)
        argerror("index out of range");
    f1.upValues[n1 - 1] = f2.upValues[n2 - 1];
    return NONE;
}
 

public void onCall(LuaClosure c, Varargs varargs, LuaValue[] stack) {
    LuaThread t = globals.running;
    callstack().onCall(c, varargs, stack);

    if (t.inhook) return;
    if (t.hookcall && t.hookfunc != null)
        callHook(CALL, NIL);
}
 

static LuaString findupvalue(LuaClosure c, int up) {
    if (c.upValues != null && up > 0 && up <= c.upValues.length) {
        if (c.p.upvalues != null && up <= c.p.upvalues.length)
            return c.p.upvalues[up - 1].name;
        else
            return LuaString.valueOf("." + up);
    }
    return null;
}
 

/**
 * string.dump (function)
 * <p>
 * Returns a string containing a binary representation of the given function,
 * so that a later loadstring on this string returns a copy of the function.
 * function must be a Lua function without upvalues.
 * <p>
 * TODO: port dumping code as optional add-on
 */
static LuaValue dump(LuaValue arg) {
    LuaValue f = arg.checkfunction();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
        DumpState.dump(((LuaClosure) f).p, baos, true);
        return LuaString.valueOf(baos.toByteArray());
    } catch (IOException e) {
        return error(e.getMessage());
    }
}
 

public LuaFunction load(Prototype prototype, String chunkname, LuaValue env) throws IOException {
	return new LuaClosure(prototype, env);
}
 

void set(LuaClosure function, Varargs varargs, LuaValue[] stack) {
	this.f = function;
	this.v = varargs;
	this.stack = stack;
}