Tasks | ||
---|---|---|
![]() |
![]() |
|
Concepts | Updating This Document |
See Buildpath.
You can add a folder in the source path by right clicking on it and select
BuildPath > Use as Source Folder
On the project o which you want to add a dependency, right click and select''Build Path > Configure Build Path ...''.
Then select the Projects tab and use the Add button to create the dependency.
To find preferences related to Execution Environments, go to Window > Preferences > Lua > Execution Environments and you will have the following interface.
As you can see in previous screenshot, LDT is shipped with a Lua 5.1 Execution Environment. All Execution Environments shipped with LDT are suffixed by (embedded).
From here, is it possible to add an Execution Environment to current workspace. First, download an Execution Environment from the list of available Execution Environments or create your one Execution Environment. Then, back to the Execution Environments preference page, push Add button and select an Execution Environment file.
The Execution Environment is now available to use.
''If you need to override an installed embedded Execution Environment, create a new Execution Environment with the same name and add it. All the projects using the embedded Execution Environment will automatically use the new one.''
If you have created a project without Execution Environment, you can add one afterwards. Right click on a project and select Build Path > Add Libraries .... Be aware that only one Execution Environment is expected per project.
You will have to choose between several libraries types, choose Lua Execution Environment.
You can now choose among installed Execution Environments and press Finish.
It is now linked to selected project.
Interpreters are used by LDT to run scripts on local computers, see Interpreters.
An embedded interpreter is an interpreter shipped with LDT. You can recognize them on the interpreter preference page, their location is mentioned as (embedded). Currently, LDT is shipped with the JNLua (Lua 5.1) embedded interpreter, JNLua is Java binding of Lua interpreter and APIs.
To run Lua scripts in LDT using the Lua Local Application launch configuration with a locally installed Lua interpreter, you have to configure a local interpreter. To configure an interpreter you just need the path of the interpreter executable, then you can set interpreter arguments and some environment variables.
See below how to reference a Lua interpreter installed on your machine, and use it in LDT.
To open the Interpreters preference page go to
Window > Preferences > Lua > Interpreters:
Then, press the Add... button to configure a new interpreter and fill in the fields as described here:
lua
).
Once you press the
Ok button, the created interpreter appears in the Interpreters page. The checkbox in front of each interpreter allows to check the default interpreter used in launch configurations.
See the explanation about the three way to debug in LDT.
According to your interpreter capabilities set in the interpreter preference if your interpreter doesn't handle the "-e" option. You have to launch the debugger by adding the following code :
if os.getenv('DEBUG_MODE') then require "debugger"() end
Note: The
DEBUG_MODE
environment variable is set only for
debug, to avoid to start the debugger for a regular
run.
Create a Lua Application launch configuration in the
Debug Configuration menu.
In the
Main tab, you can select the project, the script you want to launch and a Lua interpreter.
In the
Arguments tab, you can specify interpreter arguments and script arguments.
The interpreter arguments will be merged to the ones specified at the interpreter level (in the interpreter preference page) at runtime.
In the
Environment tab, you can specify environment variables for runtime.
Environment variable defined can be append
In the Common tab, you can set some settings related to launch configurations:
The Debugger of Lua Development Tools is based on the DBGp protocol, and the IDE implements a DBGp server.
To connect to this server, and start remote/attach debugging, you need to use a DBGp Lua client.
The DBGp Lua client is a Lua file which can be downloaded through the
Lua Attach to Application launch configuration UI.
It runs on Unix-like OS and Windows (XP and later). It is written in
Lua and
depends on lua-socket.
You can get Lua at
http://www.lua.org/download.html and install lua-socket thanks to
luarocks, or via your official OS repositories.
If, for some reasons, you cannot use lua-socket, you could implement your own transport interface based on your own library (see the
interface and the
transport parameter)
To use it, you must have the debugger.lua file in your Lua path.
To begin the connection, you must execute this Lua code :
> local initconnection = require("debugger") > initconnection(idehost, ideport, idekey,)
which can be shortened like this:
> require("debugger")(idehost, ideport, idekey)
Advanced optional parameters :
So, to debug any Lua script, you can do:
lua -e "require('debugger')('idehost', 'ideport');" MyApp.lua
or even just go with:
lua -e "require('debugger')();" MyApp.lua
If you want to rely on default values for the debug host and port (which should be 127.0.0.1:10000 if you didn't tweak any DBGP_* environment variable).
Console output
The DBGp Server is integrated in
LDT.
In order to accept incoming debug sessions, you must create a new
Lua Attach to Application launch configuration, then launch it.
Go in Run/Debug Configurations....
Now you can start your debug session by clicking
Debug. IDE will wait for an incoming connection from the debugger client, on the port you can see in the debug view. By default, the port used is 10000, but if it is taken, another one may be used.
If needed, you can change the server port, in Window > Preferences > Dynamic Languages > Debug.
As the remote debugging is an advanced feature and is not required by most Lua developers. The remote debugging is not shipped with LDT and have to be downloaded and installed afterwards. To install the LDT remote feature, first select the top menu Help / Install New Software...
On the LDT update site select the remote feature in the list and install it. (see LDT update sites documentation)
In the Remote System Explorer perspective, in the new wizard, create a new Connection and select the Lua SSH System kind of system.
On the next page, enter the network name of your remote system, or directly its IP address.
If needed, configure the runtime paths in ssh-lua sub-system advanced properties. If paths are not configured, the remote sytems's environment variables will be used. To change the properties, select the SSH Lua node of your connection. Then, in the property view bellow push the show advanced properties button. You can edit properties values by selecting the appropriate cell. If you let some properties empty, the remote system Lua defaults will be used.
User environment variable limitation:
In the top menu, select Run/Debug Configuration....
Then, create a Remote Lua Application launch configuration. Configure the project and the script to run, also select the remote system.
The following tabs are also provided to configure your launch configuration:
Launch the debug session, see how Debugging a Lua program to continue.
See how to launch debug in previous section called Configuring debug sessions .
You can set breakpoints at a particular file or line, you can do it with the regular double-click on margin:
You can optionally indicate conditions to stop execution only under specific circumstances:
Once a breakpoint has been hit, and the execution has actually stopped, you can use the
Step Into,
Step Over and
Step Return commands.
Coroutine handling:
When a breakpoint is reached, you can see any variable visible from any stack frame (local, upvalue and global variables). You can also edit values.
New values are expressions:
Some special values can also be displayed such as metatables or function environments (if it is different from global environment). You can also edit them.
In addition to variable view, you have two other useful tools to evaluate some code snippets: expressions view and interactive console.
Always on top level:
The dynamic code is not supported, it means that any code that is loaded with load, loadstring will not be supported. The debugger will step over it just like a C function.
If you are working with LuaJIT's cdata and want to improve their display during debug, simply add this line at the top of your application entry point (by default main.lua):
require 'debugger.plugins.ffi'
We implemented a custom inspector for cdata display, it will enable you to browse their structure and values.
![]() |
![]() |
![]() |
Concepts | Updating This Document |