#include <simgear/math/sg_random.h>
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/sg_dir.hxx>
+#include <simgear/misc/SimpleMarkdown.hxx>
#include <simgear/structure/commands.hxx>
#include <simgear/math/sg_geodesy.hxx>
#include <simgear/structure/event_mgr.hxx>
#include <simgear/nasal/cppbind/Ghost.hxx>
#include <simgear/nasal/cppbind/NasalHash.hxx>
+#include "NasalSGPath.hxx"
#include "NasalSys.hxx"
#include "NasalSys_private.hxx"
+#include "NasalAircraft.hxx"
#include "NasalModelData.hxx"
#include "NasalPositioned.hxx"
#include "NasalCanvas.hxx"
#include "NasalClipboard.hxx"
#include "NasalCondition.hxx"
+#include "NasalHTTP.hxx"
#include "NasalString.hxx"
#include <Main/globals.hxx>
#include <Main/util.hxx>
#include <Main/fg_props.hxx>
-#include <Main/FGInterpolator.hxx>
using std::map;
+using std::string;
+using std::vector;
void postinitNasalGUI(naRef globals, naContext c);
_sys->gcRelease(_gcSelf);
}
+ bool isRunning() const { return _isRunning; }
+
void stop()
{
if (_isRunning) {
if (_singleShot) {
globals->get_event_mgr()->addEvent(_name, this, &TimerObj::invoke, _interval);
} else {
- globals->get_event_mgr()->addTask(_name, this, &TimerObj::invoke, _interval);
+ globals->get_event_mgr()->addTask(_name, this, &TimerObj::invoke,
+ _interval, _interval /* delay */);
}
}
void invoke()
{
+ if( _singleShot )
+ // Callback may restart the timer, so update status before callback is
+ // called (Prevent warnings of deleting not existing tasks from the
+ // event manager).
+ _isRunning = false;
+
naRef *args = NULL;
_sys->callMethod(_func, _self, 0, args, naNil() /* locals */);
}
return buf;
}
-FGNasalSys::FGNasalSys()
+FGNasalSys::FGNasalSys() :
+ _inited(false)
{
nasalSys = this;
_context = 0;
_globals = naNil();
_string = naNil();
- _gcHash = naNil();
- _nextGCKey = 0; // Any value will do
- _callCount = 0;
+ _wrappedNodeFunc = naNil();
_log = new simgear::BufferedLogCallback(SG_NASAL, SG_INFO);
_log->truncateAt(255);
sglog().addCallback(_log);
+
+ naSetErrorHandler(&logError);
}
// Utility. Sets a named key in a hash by C string, rather than nasal
return callMethod(code, naNil(), argc, args, locals);
}
+naRef FGNasalSys::callWithContext(naContext ctx, naRef code, int argc, naRef* args, naRef locals)
+{
+ return callMethodWithContext(ctx, code, naNil(), argc, args, locals);
+}
+
// Does a naCall() in a new context. Wrapped here to make lock
// tracking easier. Extension functions are called with the lock, but
// we have to release it before making a new naCall(). So rather than
naRef FGNasalSys::callMethod(naRef code, naRef self, int argc, naRef* args, naRef locals)
{
- naContext ctx = naNewContext();
- if(_callCount) naModUnlock();
- _callCount++;
- naRef result = naCall(ctx, code, argc, args, self, locals);
- if(naGetError(ctx))
- logError(ctx);
- _callCount--;
- if(_callCount) naModLock();
- naFreeContext(ctx);
- return result;
+ return naCallMethod(code, self, argc, args, locals);
+}
+
+naRef FGNasalSys::callMethodWithContext(naContext ctx, naRef code, naRef self, int argc, naRef* args, naRef locals)
+{
+ return naCallMethodCtx(ctx, code, self, argc, args, locals);
}
FGNasalSys::~FGNasalSys()
{
+ if (_inited) {
+ SG_LOG(SG_GENERAL, SG_ALERT, "Nasal was not shutdown");
+ }
nasalSys = 0;
- map<int, FGNasalListener *>::iterator it, end = _listener.end();
- for(it = _listener.begin(); it != end; ++it)
- delete it->second;
-
- naFreeContext(_context);
- _globals = naNil();
- _string = naNil();
}
bool FGNasalSys::parseAndRun(const char* sourceCode)
{
- naRef code = parse("FGNasalSys::parseAndRun()", sourceCode,
+ naContext ctx = naNewContext();
+ naRef code = parse(ctx, "FGNasalSys::parseAndRun()", sourceCode,
strlen(sourceCode));
- if(naIsNil(code))
+ if(naIsNil(code)) {
+ naFreeContext(ctx);
return false;
- call(code, 0, 0, naNil());
+ }
+ callWithContext(ctx, code, 0, 0, naNil());
+ naFreeContext(ctx);
return true;
}
// This allows a Nasal object to hold onto a property path and use it
// like a node object, e.g. setprop(ObjRoot, "size-parsecs", 2.02). This
// is the utility function that walks the property tree.
-// Future enhancement: support integer arguments to specify array
-// elements.
-static SGPropertyNode* findnode(naContext c, naRef* vec, int len)
+static SGPropertyNode* findnode(naContext c, naRef* vec, int len, bool create=false)
{
SGPropertyNode* p = globals->get_props();
try {
for(int i=0; i<len; i++) {
naRef a = vec[i];
- if(!naIsString(a)) return 0;
- p = p->getNode(naStr_data(a));
+ if(!naIsString(a)) {
+ naRuntimeError(c, "bad argument to setprop/getprop path: expected a string");
+ }
+ naRef b = i < len-1 ? naNumValue(vec[i+1]) : naNil();
+ if (!naIsNil(b)) {
+ p = p->getNode(naStr_data(a), (int)b.num, create);
+ i++;
+ } else {
+ p = p->getNode(naStr_data(a), create);
+ }
if(p == 0) return 0;
}
} catch (const string& err) {
naRuntimeError(c, (char *)err.c_str());
- return 0;
}
return p;
}
static naRef f_getprop(naContext c, naRef me, int argc, naRef* args)
{
using namespace simgear;
- const SGPropertyNode* p = findnode(c, args, argc);
+ if (argc < 1) {
+ naRuntimeError(c, "getprop() expects at least 1 argument");
+ }
+ const SGPropertyNode* p = findnode(c, args, argc, false);
if(!p) return naNil();
switch(p->getType()) {
// final argument.
static naRef f_setprop(naContext c, naRef me, int argc, naRef* args)
{
-#define BUFLEN 1024
- char buf[BUFLEN + 1];
- buf[BUFLEN] = 0;
- char* p = buf;
- int buflen = BUFLEN;
- if(argc < 2) naRuntimeError(c, "setprop() expects at least 2 arguments");
- for(int i=0; i<argc-1; i++) {
- naRef s = naStringValue(c, args[i]);
- if(naIsNil(s)) return naNil();
- strncpy(p, naStr_data(s), buflen);
- p += naStr_len(s);
- buflen = BUFLEN - (p - buf);
- if(i < (argc-2) && buflen > 0) {
- *p++ = '/';
- buflen--;
- }
+ if (argc < 2) {
+ naRuntimeError(c, "setprop() expects at least 2 arguments");
}
+ naRef val = args[argc - 1];
+ SGPropertyNode* p = findnode(c, args, argc-1, true);
- SGPropertyNode* props = globals->get_props();
- naRef val = args[argc-1];
bool result = false;
try {
- if(naIsString(val)) result = props->setStringValue(buf, naStr_data(val));
+ if(naIsString(val)) result = p->setStringValue(naStr_data(val));
else {
- naRef n = naNumValue(val);
- if(naIsNil(n))
+ if(!naIsNum(val))
naRuntimeError(c, "setprop() value is not string or number");
- if (SGMisc<double>::isNaN(n.num)) {
+ if (SGMisc<double>::isNaN(val.num)) {
naRuntimeError(c, "setprop() passed a NaN");
}
- result = props->setDoubleValue(buf, n.num);
+ result = p->setDoubleValue(val.num);
}
} catch (const string& err) {
naRuntimeError(c, (char *)err.c_str());
}
return naNum(result);
-#undef BUFLEN
}
// print() extension function. Concatenates and prints its arguments
}
TimerObj* timerObj = new TimerObj(nasalSys, func, self, args[0].num);
- return NasalTimerObj::create(c, timerObj);
+ return nasal::to_nasal(c, timerObj);
}
// setlistener(func, property, bool) extension function. Falls through to
// value/delta numbers.
static naRef f_interpolate(naContext c, naRef me, int argc, naRef* args)
{
- FGInterpolator* mgr =
- static_cast<FGInterpolator*>
- (
- globals->get_subsystem_mgr()
- ->get_group(SGSubsystemMgr::INIT)
- ->get_subsystem("prop-interpolator")
- );
- if( !mgr )
- {
- SG_LOG(SG_GENERAL, SG_WARN, "No property interpolator available");
- return naNil();
- };
-
SGPropertyNode* node;
naRef prop = argc > 0 ? args[0] : naNil();
if(naIsString(prop)) node = fgGetNode(naStr_data(prop), true);
deltas.push_back(naNumValue(naVec_get(curve, 2*i+1)).num);
}
- mgr->interpolate
- (
- node,
- "numeric",
- value_nodes,
- deltas,
- "linear"
- );
-
+ node->interpolate("numeric", value_nodes, deltas, "linear");
return naNil();
}
return naStr_fromdata(naNewString(c), const_cast<char*>(pdata), strlen(pdata));
}
+static naRef f_findDataDir(naContext c, naRef me, int argc, naRef* args)
+{
+ if(argc != 1 || !naIsString(args[0]))
+ naRuntimeError(c, "bad arguments to findDataDir()");
+
+ SGPath p = globals->find_data_dir(naStr_data(args[0]));
+ const char* pdata = p.c_str();
+ return naStr_fromdata(naNewString(c), const_cast<char*>(pdata), strlen(pdata));
+}
+
class NasalCommand : public SGCommandMgr::Command
{
public:
- NasalCommand(FGNasalSys* sys, naRef f) :
+ NasalCommand(FGNasalSys* sys, naRef f, const std::string& name) :
_sys(sys),
- _func(f)
+ _func(f),
+ _name(name)
{
+ globals->get_commands()->addCommandObject(_name, this);
_gcRoot = sys->gcSave(f);
}
FGNasalSys* _sys;
naRef _func;
int _gcRoot;
+ std::string _name;
};
static naRef f_addCommand(naContext c, naRef me, int argc, naRef* args)
if(argc != 2 || !naIsString(args[0]) || !naIsFunc(args[1]))
naRuntimeError(c, "bad arguments to addcommand()");
- naRef func = args[1];
- NasalCommand* cmd = new NasalCommand(nasalSys, func);
- globals->get_commands()->addCommandObject(naStr_data(args[0]), cmd);
+ nasalSys->addCommand(args[1], naStr_data(args[0]));
return naNil();
}
static naRef f_removeCommand(naContext c, naRef me, int argc, naRef* args)
{
- SGCommandMgr::Command* cmd = globals->get_commands()->getCommand(naStr_data(args[0]));
-
- // SGCommandMgr::Command* cmd = globals->get_commands()->removeCommand(naStr_data(args[0]))
-
- delete cmd;
+ if ((argc < 1) || !naIsString(args[0]))
+ naRuntimeError(c, "bad argument to removecommand()");
+ globals->get_commands()->removeCommand(naStr_data(args[0]));
return naNil();
}
return naStr_fromdata(naNewString(c), const_cast<char*>(file), strlen(file));
}
+/**
+ * Parse very simple and small subset of markdown
+ *
+ * parse_markdown(src)
+ */
+static naRef f_parse_markdown(naContext c, naRef me, int argc, naRef* args)
+{
+ nasal::CallContext ctx(c, me, argc, args);
+ return ctx.to_nasal(
+ simgear::SimpleMarkdown::parse(ctx.requireArg<std::string>(0))
+ );
+}
+
+/**
+ * Create md5 hash from given string
+ *
+ * md5(str)
+ */
+static naRef f_md5(naContext c, naRef me, int argc, naRef* args)
+{
+ if( argc != 1 || !naIsString(args[0]) )
+ naRuntimeError(c, "md5(): wrong type or number of arguments");
+
+ return nasal::to_nasal(
+ c,
+ simgear::strutils::md5(naStr_data(args[0]), naStr_len(args[0]))
+ );
+}
+
// Return UNIX epoch time in seconds.
static naRef f_systime(naContext c, naRef me, int argc, naRef* args)
{
{ "abort", f_abort },
{ "directory", f_directory },
{ "resolvepath", f_resolveDataPath },
+ { "finddata", f_findDataDir },
{ "parsexml", f_parsexml },
+ { "parse_markdown", f_parse_markdown },
+ { "md5", f_md5 },
{ "systime", f_systime },
{ 0, 0 }
};
void FGNasalSys::init()
{
+ if (_inited) {
+ SG_LOG(SG_GENERAL, SG_ALERT, "duplicate init of Nasal");
+ }
int i;
_context = naNewContext();
// And our SGPropertyNode wrapper
hashset(_globals, "props", genPropsModule());
- // Make a "__gcsave" hash to hold the naRef objects which get
- // passed to handles outside the interpreter (to protect them from
- // begin garbage-collected).
- _gcHash = naNewHash(_context);
- hashset(_globals, "__gcsave", _gcHash);
-
// Add string methods
_string = naInit_string(_context);
naSave(_context, _string);
- initNasalString(_globals, _string, _context, _gcHash);
+ initNasalString(_globals, _string, _context);
- initNasalPositioned(_globals, _context, _gcHash);
- initNasalPositioned_cppbind(_globals, _context, _gcHash);
+ initNasalPositioned(_globals, _context);
+ initNasalPositioned_cppbind(_globals, _context);
+ initNasalAircraft(_globals, _context);
NasalClipboard::init(this);
- initNasalCanvas(_globals, _context, _gcHash);
- initNasalCondition(_globals, _context, _gcHash);
+ initNasalCanvas(_globals, _context);
+ initNasalCondition(_globals, _context);
+ initNasalHTTP(_globals, _context);
+ initNasalSGPath(_globals, _context);
NasalTimerObj::init("Timer")
.method("start", &TimerObj::start)
.method("stop", &TimerObj::stop)
.method("restart", &TimerObj::restart)
- .member("singleShot", &TimerObj::isSingleShot, &TimerObj::setSingleShot);
-
+ .member("singleShot", &TimerObj::isSingleShot, &TimerObj::setSingleShot)
+ .member("isRunning", &TimerObj::isRunning);
+
// Now load the various source files in the Nasal directory
simgear::Dir nasalDir(SGPath(globals->get_fg_root(), "Nasal"));
loadScriptDirectory(nasalDir);
const char *s = "nasal-dir-initialized";
SGPropertyNode *signal = fgGetNode("/sim/signals", true);
signal->setBoolValue(s, true);
- signal->removeChildren(s, false);
+ signal->removeChildren(s);
// Pull scripts out of the property tree, too
loadPropertyScripts();
// now Nasal modules are loaded, we can do some delayed work
postinitNasalPositioned(_globals, _context);
postinitNasalGUI(_globals, _context);
+
+ _inited = true;
+}
+
+void FGNasalSys::shutdown()
+{
+ if (!_inited) {
+ return;
+ }
+
+ shutdownNasalPositioned();
+
+ map<int, FGNasalListener *>::iterator it, end = _listener.end();
+ for(it = _listener.begin(); it != end; ++it)
+ delete it->second;
+ _listener.clear();
+
+ NasalCommandDict::iterator j = _commands.begin();
+ for (; j != _commands.end(); ++j) {
+ globals->get_commands()->removeCommand(j->first);
+ }
+ _commands.clear();
+
+ std::vector<FGNasalModuleListener*>::iterator k = _moduleListeners.begin();
+ for(; k!= _moduleListeners.end(); ++k)
+ delete *k;
+ _moduleListeners.clear();
+
+ naClearSaved();
+
+ _string = naNil(); // will be freed by _context
+ naFreeContext(_context);
+
+ //setWatchedRef(_globals);
+
+ // remove the recursive reference in globals
+ hashset(_globals, "globals", naNil());
+ _globals = naNil();
+
+ naGC();
+ _inited = false;
}
naRef FGNasalSys::wrappedPropsNode(SGPropertyNode* aProps)
{
- static naRef wrapNodeFunc = naNil();
- if (naIsNil(wrapNodeFunc)) {
- nasal::Hash g(_globals, _context);
- nasal::Hash props = g.get<nasal::Hash>("props");
- wrapNodeFunc = props.get("wrapNode");
+ if (naIsNil(_wrappedNodeFunc)) {
+ nasal::Hash props = getGlobals().get<nasal::Hash>("props");
+ _wrappedNodeFunc = props.get("wrapNode");
}
naRef args[1];
args[0] = propNodeGhost(aProps);
- return naCall(_context, wrapNodeFunc, 1, args, naNil(), naNil());
+ naContext ctx = naNewContext();
+ naRef wrapped = naCall(ctx, _wrappedNodeFunc, 1, args, naNil(), naNil());
+ naFreeContext(ctx);
+ return wrapped;
}
void FGNasalSys::update(double)
if (!_loadList.empty())
{
- // process Nasal load hook (only one per update loop to avoid excessive lags)
- _loadList.pop()->load();
+ if( _delay_load )
+ _delay_load = false;
+ else
+ // process Nasal load hook (only one per update loop to avoid excessive lags)
+ _loadList.pop()->load();
}
else
if (!_unloadList.empty())
_unloadList.pop()->unload();
}
+ // Destroy all queued ghosts
+ nasal::ghostProcessDestroyList();
+
// The global context is a legacy thing. We use dynamically
// created contexts for naCall() now, so that we can call them
// recursively. But there are still spots that want to use it for
// Create module with list of scripts
void FGNasalSys::addModule(string moduleName, simgear::PathList scripts)
{
- if (scripts.size()>0)
+ if (! scripts.empty())
{
SGPropertyNode* nasal = globals->get_props()->getNode("nasal");
SGPropertyNode* module_node = nasal->getChild(moduleName,0,true);
if (enable)
{
FGNasalModuleListener* listener = new FGNasalModuleListener(n);
+ _moduleListeners.push_back(listener);
enable->addChangeListener(listener, false);
}
}
// Logs a runtime error, with stack trace, to the FlightGear log stream
void FGNasalSys::logError(naContext context)
{
- SG_LOG(SG_NASAL, SG_ALERT,
- "Nasal runtime error: " << naGetError(context));
+ SG_LOG(SG_NASAL, SG_ALERT, "Nasal runtime error: " << naGetError(context));
+ int stack_depth = naStackDepth(context);
+ if( stack_depth < 1 )
+ return;
SG_LOG(SG_NASAL, SG_ALERT,
" at " << naStr_data(naGetSourceFile(context, 0)) <<
", line " << naGetLine(context, 0));
- for(int i=1; i<naStackDepth(context); i++)
+ for(int i=1; i<stack_depth; i++)
SG_LOG(SG_NASAL, SG_ALERT,
" called from: " << naStr_data(naGetSourceFile(context, i)) <<
", line " << naGetLine(context, i));
const SGPropertyNode* cmdarg,
int argc, naRef* args)
{
- naRef code = parse(fileName, src, len);
- if(naIsNil(code))
+ naContext ctx = naNewContext();
+ naRef code = parse(ctx, fileName, src, len);
+ if(naIsNil(code)) {
+ naFreeContext(ctx);
return false;
+ }
+
// See if we already have a module hash to use. This allows the
// user to, for example, add functions to the built-in math
// module. Make a new one if necessary.
naRef locals;
- naRef modname = naNewString(_context);
+ naRef modname = naNewString(ctx);
naStr_fromdata(modname, (char*)moduleName, strlen(moduleName));
if(!naHash_get(_globals, modname, &locals))
- locals = naNewHash(_context);
+ locals = naNewHash(ctx);
_cmdArg = (SGPropertyNode*)cmdarg;
- call(code, argc, args, locals);
+ callWithContext(ctx, code, argc, args, locals);
hashset(_globals, moduleName, locals);
+
+ naFreeContext(ctx);
return true;
}
void FGNasalSys::deleteModule(const char* moduleName)
{
- naRef modname = naNewString(_context);
+ if (!_inited) {
+ // can occur on shutdown due to us being shutdown first, but other
+ // subsystems having Nasal objects.
+ return;
+ }
+
+ naContext ctx = naNewContext();
+ naRef modname = naNewString(ctx);
naStr_fromdata(modname, (char*)moduleName, strlen(moduleName));
naHash_delete(_globals, modname);
+ naFreeContext(ctx);
}
-naRef FGNasalSys::parse(const char* filename, const char* buf, int len)
+naRef FGNasalSys::parse(naContext ctx, const char* filename, const char* buf, int len)
{
int errLine = -1;
- naRef srcfile = naNewString(_context);
+ naRef srcfile = naNewString(ctx);
naStr_fromdata(srcfile, (char*)filename, strlen(filename));
- naRef code = naParseCode(_context, srcfile, 1, (char*)buf, len, &errLine);
+ naRef code = naParseCode(ctx, srcfile, 1, (char*)buf, len, &errLine);
if(naIsNil(code)) {
SG_LOG(SG_NASAL, SG_ALERT,
- "Nasal parse error: " << naGetError(_context) <<
+ "Nasal parse error: " << naGetError(ctx) <<
" in "<< filename <<", line " << errLine);
return naNil();
}
// Bind to the global namespace before returning
- return naBindFunction(_context, code, _globals);
+ return naBindFunction(ctx, code, _globals);
}
bool FGNasalSys::handleCommand( const char* moduleName,
const char* src,
const SGPropertyNode* arg )
{
- naRef code = parse(fileName, src, strlen(src));
- if(naIsNil(code)) return false;
+ naContext ctx = naNewContext();
+ naRef code = parse(ctx, fileName, src, strlen(src));
+ if(naIsNil(code)) {
+ naFreeContext(ctx);
+ return false;
+ }
// Commands can be run "in" a module. Make sure that module
// exists, and set it up as the local variables hash for the
// command.
naRef locals = naNil();
if(moduleName[0]) {
- naRef modname = naNewString(_context);
+ naRef modname = naNewString(ctx);
naStr_fromdata(modname, (char*)moduleName, strlen(moduleName));
if(!naHash_get(_globals, modname, &locals)) {
- locals = naNewHash(_context);
+ locals = naNewHash(ctx);
naHash_set(_globals, modname, locals);
}
}
// code doesn't need it.
_cmdArg = (SGPropertyNode*)arg;
- call(code, 0, 0, locals);
+ callWithContext(ctx, code, 0, 0, locals);
+ naFreeContext(ctx);
return true;
}
const char* moduleName = arg->getStringValue("module");
return handleCommand( moduleName,
- arg ? arg->getPath(true).c_str() : moduleName,
+ arg->getPath(true).c_str(),
src,
arg );
}
int FGNasalSys::gcSave(naRef r)
{
- int key = _nextGCKey++;
- naHash_set(_gcHash, naNum(key), r);
- return key;
+ return naGCSave(r);
}
void FGNasalSys::gcRelease(int key)
{
- naHash_delete(_gcHash, naNum(key));
+ naGCRelease(key);
}
void FGNasalSys::NasalTimer::timerExpired()
void FGNasalSys::registerToLoad(FGNasalModelData *data)
{
- _loadList.push(data);
+ if( _loadList.empty() )
+ _delay_load = true;
+ _loadList.push(data);
}
void FGNasalSys::registerToUnload(FGNasalModelData *data)
_unloadList.push(data);
}
+void FGNasalSys::addCommand(naRef func, const std::string& name)
+{
+ if (_commands.find(name) != _commands.end()) {
+ SG_LOG(SG_NASAL, SG_WARN, "duplicate add of command:" << name);
+ return;
+ }
+
+ NasalCommand* cmd = new NasalCommand(this, func, name);
+ _commands[name] = cmd;
+}
+
+void FGNasalSys::removeCommand(const std::string& name)
+{
+ NasalCommandDict::iterator it = _commands.find(name);
+ if (it == _commands.end()) {
+ SG_LOG(SG_NASAL, SG_WARN, "remove of unknwon command:" << name);
+ return;
+ }
+
+ // will delete the NasalCommand instance
+ globals->get_commands()->removeCommand(name);
+ _commands.erase(it);
+}
+
//////////////////////////////////////////////////////////////////////////
// FGNasalListener class.
void FGNasalListener::call(SGPropertyNode* which, naRef mode)
{
if(_active || _dead) return;
- SG_LOG(SG_NASAL, SG_DEBUG, "trigger listener #" << _id);
_active++;
naRef arg[4];
arg[0] = _nas->propNodeGhost(which);
projects / flightgear.git / blobdiff