mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-07 04:00:37 -06:00
553 lines
17 KiB
C++
553 lines
17 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2015 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include <openspace/scripting/scriptengine.h>
|
|
|
|
#include <ghoul/logging/logmanager.h>
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <openspace/util/syncbuffer.h>
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/network/osparallelconnection.h>
|
|
#include <ghoul/lua/lua_helper.h>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
|
|
#include "scriptengine_lua.inl"
|
|
|
|
namespace openspace {
|
|
|
|
namespace scripting {
|
|
|
|
namespace {
|
|
const std::string _loggerCat = "ScriptEngine";
|
|
|
|
const std::string _openspaceLibraryName = "openspace";
|
|
const std::string _luaGlobalNamespace = "_G";
|
|
const std::string _printFunctionName = "print";
|
|
//const lua_CFunction _printFunctionReplacement = luascriptfunctions::printInfo;
|
|
|
|
const int _setTableOffset = -3; // -1 (top) -1 (first argument) -1 (second argument)
|
|
|
|
}
|
|
|
|
bool ScriptEngine::LuaLibrary::operator<(const LuaLibrary& rhs) const {
|
|
return name < rhs.name;
|
|
}
|
|
|
|
ScriptEngine::ScriptEngine()
|
|
: _state(nullptr)
|
|
{
|
|
}
|
|
|
|
ScriptEngine::~ScriptEngine() {
|
|
//deinitialize();
|
|
}
|
|
|
|
bool ScriptEngine::initialize() {
|
|
LDEBUG("Adding base functions");
|
|
addBaseLibrary();
|
|
|
|
_state = luaL_newstate();
|
|
LDEBUG("Creating Lua state");
|
|
if (_state == nullptr) {
|
|
LFATAL("Error creating new Lua state: Memory allocation error");
|
|
return false;
|
|
}
|
|
|
|
LDEBUG("Open Lua libraries");
|
|
luaL_openlibs(_state);
|
|
|
|
initializeLuaState(_state);
|
|
|
|
LDEBUG("Remap print function");
|
|
remapPrintFunction();
|
|
|
|
return true;
|
|
}
|
|
|
|
void ScriptEngine::deinitialize() {
|
|
if (_state) {
|
|
lua_close(_state);
|
|
_state = nullptr;
|
|
}
|
|
}
|
|
|
|
void ScriptEngine::addLibrary(LuaLibrary library) {
|
|
auto sortFunc = [](const LuaLibrary::Function& lhs, const LuaLibrary::Function& rhs)
|
|
{
|
|
return lhs.name < rhs.name;
|
|
};
|
|
|
|
// do we have a library with the same name as the incoming one
|
|
auto it = std::find_if(_registeredLibraries.begin(), _registeredLibraries.end(),
|
|
[&library](const LuaLibrary& lib) { return lib.name == library.name; });
|
|
|
|
if (it == _registeredLibraries.end()) {
|
|
// If not, we can add it after we sorted it
|
|
std::sort(library.functions.begin(), library.functions.end(), sortFunc);
|
|
_registeredLibraries.insert(std::move(library));
|
|
}
|
|
else {
|
|
// otherwise, we merge the libraries
|
|
|
|
LuaLibrary merged = *it;
|
|
for (const LuaLibrary::Function& fun : library.functions) {
|
|
auto it = std::find_if(merged.functions.begin(), merged.functions.end(),
|
|
[&fun](const LuaLibrary::Function& function) {
|
|
return fun.name == function.name;
|
|
});
|
|
if (it != merged.functions.end()) {
|
|
// the function with the desired name is already present, but we don't
|
|
// want to overwrite it
|
|
LERROR("Lua function '" << fun.name << "' in library '" << library.name <<
|
|
"' has been defined twice");
|
|
return;
|
|
}
|
|
else
|
|
merged.functions.push_back(fun);
|
|
}
|
|
|
|
_registeredLibraries.erase(it);
|
|
|
|
// Sort the merged library before inserting it
|
|
std::sort(merged.functions.begin(), merged.functions.end(), sortFunc);
|
|
_registeredLibraries.insert(std::move(merged));
|
|
}
|
|
}
|
|
|
|
bool ScriptEngine::runScript(const std::string& script) {
|
|
if (script.empty()){
|
|
LWARNING("Script was empty");
|
|
return false;
|
|
}
|
|
|
|
int status = luaL_loadstring(_state, script.c_str());
|
|
if (status != LUA_OK) {
|
|
LERROR("Error loading script: '" << lua_tostring(_state, -1) << "'");
|
|
return false;
|
|
}
|
|
|
|
//LDEBUG("Executing script");
|
|
//LINFO(script);
|
|
if (lua_pcall(_state, 0, LUA_MULTRET, 0)) {
|
|
LERROR("Error executing script: " << lua_tostring(_state, -1));
|
|
return false;
|
|
}
|
|
|
|
OsEng.parallelConnection()->sendScript(script);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ScriptEngine::runScriptFile(const std::string& filename) {
|
|
if (filename.empty()) {
|
|
LWARNING("Filename was empty");
|
|
return false;
|
|
}
|
|
if (!FileSys.fileExists(filename)) {
|
|
LERROR("Script with name '" << filename << "' did not exist");
|
|
return false;
|
|
}
|
|
|
|
int status = luaL_loadfile(_state, filename.c_str());
|
|
if (status != LUA_OK) {
|
|
LERROR("Error loading script: '" << lua_tostring(_state, -1) << "'");
|
|
return false;
|
|
}
|
|
|
|
LDEBUG("Executing script '" << filename << "'");
|
|
if (lua_pcall(_state, 0, LUA_MULTRET, 0)) {
|
|
LERROR("Error executing script: " << lua_tostring(_state, -1));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ScriptEngine::hasLibrary(const std::string& name)
|
|
{
|
|
auto it = std::find_if(
|
|
_registeredLibraries.begin(),
|
|
_registeredLibraries.end(),
|
|
[name](const LuaLibrary& it) { return it.name == name; }
|
|
);
|
|
|
|
return (it != _registeredLibraries.end());
|
|
|
|
|
|
//for (const LuaLibrary& it : _registeredLibraries) {
|
|
// if (it.name == name)
|
|
// return true;
|
|
//}
|
|
//return false;
|
|
}
|
|
|
|
bool ScriptEngine::isLibraryNameAllowed(lua_State* state, const std::string& name) {
|
|
bool result = false;
|
|
lua_getglobal(state, _openspaceLibraryName.c_str());
|
|
const bool hasOpenSpaceLibrary = lua_istable(state, -1);
|
|
if (!hasOpenSpaceLibrary) {
|
|
LFATAL("OpenSpace library was not created in initialize method");
|
|
return false;
|
|
}
|
|
lua_getfield(state, -1, name.c_str());
|
|
const int type = lua_type(state, -1);
|
|
switch (type) {
|
|
case LUA_TNONE:
|
|
case LUA_TNIL:
|
|
result = true;
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
LERROR("Library name '" << name << "' specifies a boolean");
|
|
break;
|
|
case LUA_TLIGHTUSERDATA:
|
|
LERROR("Library name '" << name << "' specifies a light user data");
|
|
break;
|
|
case LUA_TNUMBER:
|
|
LERROR("Library name '" << name << "' specifies a number");
|
|
break;
|
|
case LUA_TSTRING:
|
|
LERROR("Library name '" << name << "' specifies a string");
|
|
break;
|
|
case LUA_TTABLE: {
|
|
if (hasLibrary(name))
|
|
LERROR("Library with name '" << name << "' has been registered before");
|
|
else
|
|
LERROR("Library name '" << name << "' specifies a table");
|
|
break;
|
|
}
|
|
case LUA_TFUNCTION:
|
|
LERROR("Library name '" << name << "' specifies a function");
|
|
break;
|
|
case LUA_TUSERDATA:
|
|
LERROR("Library name '" << name << "' specifies a user data");
|
|
break;
|
|
case LUA_TTHREAD:
|
|
LERROR("Library name '" << name << "' specifies a thread");
|
|
break;
|
|
}
|
|
|
|
lua_pop(state, 2);
|
|
return result;
|
|
}
|
|
|
|
void ScriptEngine::addLibraryFunctions(lua_State* state, const LuaLibrary& library, bool replace) {
|
|
assert(state);
|
|
for (LuaLibrary::Function p : library.functions) {
|
|
if (!replace) {
|
|
//ghoul::lua::logStack(_state);
|
|
lua_getfield(state, -1, p.name.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
const bool isNil = lua_isnil(state, -1);
|
|
if (!isNil) {
|
|
LERROR("Function name '" << p.name << "' was already assigned");
|
|
return;
|
|
}
|
|
lua_pop(state, 1);
|
|
}
|
|
//ghoul::lua::logStack(_state);
|
|
lua_pushstring(state, p.name.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
lua_pushcfunction(state, p.function);
|
|
//ghoul::lua::logStack(_state);
|
|
lua_settable(state, _setTableOffset);
|
|
//ghoul::lua::logStack(_state);
|
|
}
|
|
}
|
|
|
|
void ScriptEngine::addBaseLibrary() {
|
|
LuaLibrary lib = {
|
|
"",
|
|
{
|
|
{
|
|
"printDebug",
|
|
&luascriptfunctions::printDebug,
|
|
"*",
|
|
"Logs the passed value to the installed LogManager with a "
|
|
"LogLevel of 'Debug'"
|
|
},
|
|
{
|
|
"printInfo",
|
|
&luascriptfunctions::printInfo,
|
|
"*",
|
|
"Logs the passed value to the installed LogManager with a "
|
|
" LogLevel of 'Info'"
|
|
},
|
|
{
|
|
"printWarning",
|
|
&luascriptfunctions::printWarning,
|
|
"*",
|
|
"Logs the passed value to the installed LogManager with "
|
|
"a LogLevel of 'Warning'"
|
|
},
|
|
{
|
|
"printError",
|
|
&luascriptfunctions::printError,
|
|
"*",
|
|
"Logs the passed value to the installed LogManager with a "
|
|
"LogLevel of 'Error'"
|
|
},
|
|
{
|
|
"printFatal",
|
|
&luascriptfunctions::printFatal,
|
|
"*",
|
|
"Logs the passed value to the installed LogManager with a "
|
|
"LogLevel of 'Fatal'"
|
|
},
|
|
{
|
|
"absPath",
|
|
&luascriptfunctions::absolutePath,
|
|
"string",
|
|
"Returns the absolute path to the passed path, resolving"
|
|
" path tokens as well as resolving relative paths"
|
|
},
|
|
{
|
|
"setPathToken",
|
|
&luascriptfunctions::setPathToken,
|
|
"string, string",
|
|
"Registers a new path token provided by the"
|
|
" first argument to the path provided in the second argument"
|
|
}
|
|
}
|
|
};
|
|
addLibrary(lib);
|
|
}
|
|
|
|
void ScriptEngine::remapPrintFunction() {
|
|
//ghoul::lua::logStack(_state);
|
|
// lua_getglobal(_state, _luaGlobalNamespace.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
// lua_pushstring(_state, _printFunctionName.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
// lua_pushcfunction(_state, _printFunctionReplacement);
|
|
//ghoul::lua::logStack(_state);
|
|
// lua_settable(_state, _setTableOffset);
|
|
//ghoul::lua::logStack(_state);
|
|
}
|
|
|
|
void ScriptEngine::initializeLuaState(lua_State* state) {
|
|
LDEBUG("Create openspace base library");
|
|
lua_newtable(state);
|
|
lua_setglobal(state, _openspaceLibraryName.c_str());
|
|
|
|
LDEBUG("Add OpenSpace modules");
|
|
for (const LuaLibrary& lib : _registeredLibraries)
|
|
registerLuaLibrary(state, lib);
|
|
}
|
|
|
|
bool ScriptEngine::registerLuaLibrary(lua_State* state, const LuaLibrary& library) {
|
|
assert(state);
|
|
if (library.functions.empty()) {
|
|
LERROR("Lua library '" << library.name << "' does not have any functions");
|
|
return false;
|
|
}
|
|
|
|
//ghoul::lua::logStack(_state);
|
|
lua_getglobal(state, _openspaceLibraryName.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
if (library.name.empty()) {
|
|
//ghoul::lua::logStack(_state);
|
|
addLibraryFunctions(state, library, true);
|
|
//ghoul::lua::logStack(_state);
|
|
lua_pop(state, 1);
|
|
//ghoul::lua::logStack(_state);
|
|
}
|
|
else {
|
|
const bool allowed = isLibraryNameAllowed(state, library.name);
|
|
if (!allowed)
|
|
return false;
|
|
|
|
//ghoul::lua::logStack(_state);
|
|
|
|
lua_pushstring(state, library.name.c_str());
|
|
//ghoul::lua::logStack(_state);
|
|
lua_newtable(state);
|
|
//ghoul::lua::logStack(_state);
|
|
addLibraryFunctions(state, library, false);
|
|
lua_settable(state, _setTableOffset);
|
|
//ghoul::lua::logStack(_state);
|
|
|
|
//_registeredLibraries.insert(library);
|
|
//_registeredLibraries.push_back(library);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::string> ScriptEngine::allLuaFunctions() const {
|
|
std::vector<std::string> result;
|
|
|
|
for (const LuaLibrary& library : _registeredLibraries) {
|
|
for (const LuaLibrary::Function& function : library.functions) {
|
|
std::string total = "openspace.";
|
|
if (!library.name.empty())
|
|
total += library.name + ".";
|
|
total += function.name;
|
|
result.push_back(std::move(total));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool ScriptEngine::writeDocumentation(const std::string& filename, const std::string& type) const {
|
|
if (type == "text") {
|
|
// The additional space between the longest function name and the descriptions
|
|
LDEBUG("Writing Lua documentation of type '" << type <<
|
|
"' to file '" << filename << "'");
|
|
std::ofstream file(filename);
|
|
if (!file.good()) {
|
|
LERROR("Could not open file '" << filename << "' for writing documentation");
|
|
return false;
|
|
}
|
|
|
|
auto concatenate = [](std::string library, std::string function) {
|
|
std::string total = "openspace.";
|
|
if (!library.empty())
|
|
total += std::move(library) + ".";
|
|
total += std::move(function);
|
|
return total;
|
|
};
|
|
|
|
// Settings
|
|
const unsigned int lineWidth = 80;
|
|
static const std::string whitespace = " \t";
|
|
static const std::string padding = " ";
|
|
const bool commandListArguments = true;
|
|
|
|
file << "Available commands:\n";
|
|
// Now write out the functions
|
|
for (const LuaLibrary& library : _registeredLibraries) {
|
|
for (const LuaLibrary::Function& function : library.functions) {
|
|
|
|
std::string functionName = concatenate(library.name, function.name);
|
|
file << padding << functionName;
|
|
if (commandListArguments)
|
|
file << "(" << function.argumentText << ")";
|
|
file << std::endl;
|
|
}
|
|
}
|
|
file << std::endl;
|
|
|
|
// Now write out the functions definitions
|
|
for (const LuaLibrary& library : _registeredLibraries) {
|
|
for (const LuaLibrary::Function& function : library.functions) {
|
|
|
|
std::string functionName = concatenate(library.name, function.name);
|
|
file << functionName << "(" << function.argumentText << "):" << std::endl;
|
|
|
|
std::string remainingHelptext = function.helpText;
|
|
|
|
// @CLEANUP This needs to become a bit prettier ---abock
|
|
while (!remainingHelptext.empty()) {
|
|
const auto length = remainingHelptext.length();
|
|
const auto paddingLength = padding.length();
|
|
if ((length + paddingLength) > lineWidth) {
|
|
auto lastSpace = remainingHelptext.find_last_of(whitespace, lineWidth - 1 - paddingLength);
|
|
if (lastSpace == remainingHelptext.npos)
|
|
lastSpace = lineWidth;
|
|
file << padding << remainingHelptext.substr(0, lastSpace) << std::endl;
|
|
auto firstNotSpace = remainingHelptext.find_first_not_of(whitespace, lastSpace);
|
|
if (firstNotSpace == remainingHelptext.npos)
|
|
firstNotSpace = lastSpace;
|
|
remainingHelptext = remainingHelptext.substr(firstNotSpace);
|
|
}
|
|
else {
|
|
file << padding << remainingHelptext << std::endl;
|
|
remainingHelptext = "";
|
|
}
|
|
}
|
|
file << std::endl;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else {
|
|
LERROR("Undefined type '" << type << "' for Lua documentation");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ScriptEngine::serialize(SyncBuffer* syncBuffer){
|
|
syncBuffer->encode(_currentSyncedScript);
|
|
_currentSyncedScript.clear();
|
|
}
|
|
|
|
void ScriptEngine::deserialize(SyncBuffer* syncBuffer){
|
|
syncBuffer->decode(_currentSyncedScript);
|
|
|
|
if (!_currentSyncedScript.empty()){
|
|
_mutex.lock();
|
|
_receivedScripts.push_back(_currentSyncedScript);
|
|
_mutex.unlock();
|
|
|
|
_executedScriptsMutex.lock();
|
|
_executedScripts.push_back(_currentSyncedScript);
|
|
_executedScriptsMutex.unlock();
|
|
}
|
|
}
|
|
|
|
void ScriptEngine::postSynchronizationPreDraw(){
|
|
_mutex.lock();
|
|
while(!_receivedScripts.empty()){
|
|
runScript(_receivedScripts.back());
|
|
_receivedScripts.pop_back();
|
|
}
|
|
_mutex.unlock();
|
|
}
|
|
|
|
void ScriptEngine::preSynchronization(){
|
|
|
|
_mutex.lock();
|
|
|
|
if (!_queuedScripts.empty()){
|
|
_currentSyncedScript = _queuedScripts.back();
|
|
_queuedScripts.pop_back();
|
|
|
|
//Not really a received script but the master also needs to run the script...
|
|
_receivedScripts.push_back(_currentSyncedScript);
|
|
}
|
|
|
|
_mutex.unlock();
|
|
}
|
|
|
|
void ScriptEngine::queueScript(const std::string &script){
|
|
if (script.empty())
|
|
return;
|
|
|
|
_mutex.lock();
|
|
|
|
_queuedScripts.insert(_queuedScripts.begin(), script);
|
|
|
|
_mutex.unlock();
|
|
}
|
|
|
|
std::vector<std::string> ScriptEngine::executedScripts(){
|
|
std::lock_guard<std::mutex> lockGuard(_executedScriptsMutex);
|
|
return _executedScripts;
|
|
}
|
|
|
|
|
|
} // namespace scripting
|
|
} // namespace openspace
|