Copyright © 2009-2012 Luaj.org. Freely available under the terms of the Luaj license.
introduction · examples · concepts · libraries · luaj api · parser · building · downloads · release notes
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
From the main distribution directory line type:
java -cp lib/luaj-jse-2.0.3.jar lua examples/lua/hello.lua
You should see the following output:
hello, worldTo see how luaj can be used to acccess most Java API's including swing, try:
java -cp lib/luaj-jse-2.0.3.jar lua examples/lua/swingapp.lua
From the main distribution directory line type:
java -cp lib/luaj-jse-2.0.3.jar luac examples/lua/hello.lua java -cp lib/luaj-jse-2.0.3.jar lua luac.out
The compiled output "luac.out" is lua bytecode and should run and produce the same result.
Luaj can compile to lua source code to Java source code:
java -cp lib/luaj-jse-2.0.3.jar lua2java -s examples/lua -d . hello.lua javac -cp lib/luaj-jse-2.0.3.jar hello.java java -cp "lib/luaj-jse-2.0.3.jar;." lua -l hello
The output hello.java is Java source, that implements the logic in hello.lua directly. Once hello.java is compiled into hello.class it can be required and used in place of the original lua script, but with better performance. There are no additional dependencies for compiling or running source-to-source compiled lua.
Lua scripts can also be run directly in this mode without precompiling using the lua command with the -j option when run in JDK 1.5 or higher:
java -cp lib/luaj-jse-2.0.3.jar lua -j examples/lua/hello.lua
Luaj can compile lua sources or binaries directly to java bytecode if the bcel library is on the class path. From the main distribution directory line type:
ant bcel-lib java -cp "lib/luaj-jse-2.0.3.jar;lib/bcel-5.2.jar" luajc -s examples/lua -d . hello.lua java -cp "lib/luaj-jse-2.0.3.jar;." lua -l hello
The output hello.class is Java bytecode, should run and produce the same result. There is no runtime dependency on the bcel library, but the compiled classes must be in the class path at runtime, unless runtime jit-compiling via luajc and bcel are desired (see later sections).
Lua scripts can also be run directly in this mode without precompiling using the lua command with the -b option and providing the bcel library in the class path:
java -cp "lib/luaj-jse-2.0.3.jar;lib/bcel-5.2.jar" lua -b examples/lua/hello.lua
The following pattern is used within Java SE
import org.luaj.vm2.*;
import org.luaj.vm2.lib.jse.*;
String script = "examples/lua/hello.lua";
LuaValue _G = JsePlatform.standardGlobals();
_G.get("dofile").call( LuaValue.valueOf(script) );
A simple example may be found in
examples/jse/SampleJseMain.java
You must include the library lib/luaj-jse-2.0.3.jar in your class path.
The for MIDlets the JmePlatform is used instead:
import org.luaj.vm2.*;
import org.luaj.vm2.lib.jme.*;
String script = "examples/lua/hello.lua";
LuaValue _G = JmePlatform.standardGlobals();
_G.get("dofile").call( LuaValue.valueOf(script) );
The file must be a resource within within the midlet jar for dofile() to find it. Any files included via require() must also be part of the midlet resources.
A simple example may be found in
examples/jme/SampleMIDlet.java
You must include the library lib/luaj-jme-2.0.3.jar in your midlet jar.
An ant script to build and run the midlet is in
build-midlet.xml
You must install the wireless toolkit and define WTK_HOME for this script to work.
The standard use of JSR-223 scripting engines may be used:
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine e = mgr.getEngineByExtension(".lua");
e.put("x", 25);
e.eval("y = math.sqrt(x)");
System.out.println( "y="+e.get("y") );
All standard aspects of script engines including compiled statements should be supported.
You must include the library lib/luaj-jse-2.0.3.jar in your class path.
A working example may be found in
examples/jse/ScriptEngineSample.javaTo compile and run it using Java 1.6 or higher:
javac examples/jse/ScriptEngineSample.java java -cp "lib/luaj-jse-2.0.3.jar;examples/jse" ScriptEngineSample
To exclude the lua-to-lua-bytecode compiler, do not call standardGlobals() or debugGlobals() but instead initialize globals with including only those libraries that are needed and omitting the line:
org.luaj.vm2.compiler.LuaC.install();
To compile from lua sources to Java sources for all lua loaded at runtime, install the Lua2Java compiler after globals have been created using:
org.luaj.vm2.jse.lua2java.Lua2Java.install();This uses the system Java compiler to compile from Java source to Java bytecode, and cannot compile lua binary files containing lua bytecode at runtime.
To compile from lua to Java bytecode for all lua loaded at runtime, install the LuaJC compiler after globals have been created using:
org.luaj.vm2.jse.luajc.LuaJC.install();
This will compile all lua bytecode into Java bytecode, regardless of if they are loaded as lua source or lua binary files.
The requires bcel to be on the class path, and the ClassLoader of JSE or CDC.
The following libraries are loaded by both JsePlatform.standardGlobals() and JmePlatform.standardGlobals():
base coroutine io math os package string table
The JsePlatform.standardGlobals() globals also include:
luajava
The JsePlatform.debugGlobals() and JsePlatform.debugGlobals() functions produce globals that include:
debug
The JmePlatform.standardGlobals() instantiated the io library io in
src/jme/org/luaj/vm2/lib/jme/JmeIoLib.javaThe JsePlatform.standardGlobals() includes support for random access and is in
src/jse/org/luaj/vm2/lib/jse/JseIoLib.java
The basic os library implementation us used by JmePlatform and is in:
src/core/org/luaj/lib/OsLib.javaA richer version for use by JsePlatform is :
src/jse/org/luaj/vm2/lib/jse/JseOsLib.javaTime is a represented as number of milliseconds since the epoch, and most time and date formatting, locales, and other features are not implemented.
Luaj uses WeakReferences and the OrphanedThread error to ensure that coroutines that are no longer referenced are properly garbage collected. For thread safety, OrphanedThread should not be caught by Java code. See LuaThread and OrphanedThread javadoc for details.
require 'org.luaj.vm2.lib.DebugLib'The lua command line utility includes the debug library by default.
The following lua script will open a swing frame on Java SE:
jframe = luajava.bindClass( "javax.swing.JFrame" ) frame = luajava.newInstance( "javax.swing.JFrame", "Texts" ); frame:setDefaultCloseOperation(jframe.EXIT_ON_CLOSE) frame:setSize(300,400) frame:setVisible(true)
See a longer sample in examples/lua/swingapp.lua for details, including a simple animation loop, rendering graphics, mouse and key handling, and image loading. Or try running it using:
java -cp lib/luaj-jse-2.0.3.jar lua examples/lua/swingapp.lua
The Java ME platform does not include this library, and it cannot be made to work because of the lack of a reflection API in Java ME.
The lua connand line tool includes luajava.
http://luaj.sourceforge.net/api/2.0You can also build a local version from sources using
ant doc
org.luaj.vm2.LuaValue
call(); // invoke the function with no arguments call(LuaValue arg1); // call the function with 1 argument invoke(Varargs arg); // call the function with variable arguments, variable return values get(int index); // get a table entry using an integer key get(LuaValue key); // get a table entry using an arbitrary key, may be a LuaInteger rawget(int index); // raw get without metatable calls valueOf(int i); // return LuaValue corresponding to an integer valueOf(String s); // return LuaValue corresponding to a String toint(); // return value as a Java int tojstring(); // return value as a Java String isnil(); // is the value nil NIL; // the value nil NONE; // a Varargs instance with no values
org.luaj.vm2.Varargs
narg(); // return number of arguments arg1(); // return the first argument arg(int n); // return the nth argument isnil(int n); // true if the nth argument is nil checktable(int n); // return table or throw error optlong(int n,long d); // return n if a long, d if no argument, or error if not a longSee the Varargs API for a complete list.
org.luaj.vm2.lib.ZeroArgFunction org.luaj.vm2.lib.OneArgFunction org.luaj.vm2.lib.TwoArgFunction org.luaj.vm2.lib.ThreeArgFunction org.luaj.vm2.lib.VarArgFunctionEach of these functions has an abstract method that must be implemented, and argument fixup is done automatically by the classes as each Java function is invoked.
For example, to implement a "hello, world" function, we could supply:
pubic class hello extends ZeroArgFunction {
public LuaValue call() {
env.get("print").call(valueOf("hello, world"));
}
}
The value env is the environment of the function, and is normally supplied
by the instantiating object whenever default loading is used.
Calling this function from lua could be done by:
require( 'hello' )()while calling this function from Java would look like:
new hello().call();Note that in both the lua and Java case, extra arguments will be ignored, and the function will be called. Also, no virtual machine instance is necessary to call the function. To allow for arguments, or return multiple values, extend one of the other base classes.
A plain undecorated grammer that can be used for validation is available in grammar/Lua51.jj while a grammar that generates a typed parse tree is in grammar/LuaParser.jj
To simplify the creation of abstract syntax trees from lua sources, the LuaParser class is generated as part of the JME build. To use it, provide an input stream, and invoke the root generator, which will return a Chunk if the file is valid, or throw a ParseException if there is a syntax error.
For example, to parse a file and print all variable names, use code like:
try {
String file = "main.lua";
LuaParser parser = new LuaParser(new FileInputStream(file));
Chunk chunk = parser.Chunk();
chunk.accept( new Visitor() {
public void visit(Exp.NameExp exp) {
System.out.println("Name in use: "+exp.name.name);
}
} );
} catch ( ParseException e ) {
System.out.println("parse failed: " + e.getMessage() + "\n"
+ "Token Image: '" + e.currentToken.image + "'\n"
+ "Location: " + e.currentToken.beginLine + ":" + e.currentToken.beginColumn
+ "-" + e.currentToken.endLine + "," + e.currentToken.endColumn);
}
In luaj 2.0.3 error reporting was turned on in the parser so line numbers are avaiable for most parse exceptions.
This example may be found in
examples/jse/SampleParser.java
See the org.luaj.vm2.ast package javadoc for the API relating to the syntax tree that is produced.
Other targets exist for creating distribution file an measuring code coverage of unit tests.
The main luaj JUnit tests are organized into a JUnit 3 suite:
test/junit/org/luaj/vm2/AllTests.lua
Unit test scripts can be found in these locations
test/lua/*.lua test/junit/org/luaj/vm2/compiler/lua5.1-tests.zip test/junit/org/luaj/vm2/compiler/regressions.zip test/junit/org/luaj/vm2/vm1/luajvm1-tests.zip
A build script for running unit tests and producing code coverage statistics is in
build-coverage.xmlIt relies on the cobertura code coverage library.
SourceForge Luaj Project Page SourceForge Luaj Download Areaand LuaForge:
LuaForge Luaj Project Page LuaForge Luaj Project Area
|