#include <simgear/nasal/nasal.h>
#include <simgear/props/props.hxx>
+#include <simgear/math/sg_random.h>
#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/interpolator.hxx>
#include <simgear/structure/commands.hxx>
#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
#include "NasalSys.hxx"
// etc...)
SG_LOG(SG_NASAL, SG_ALERT,
"ERROR in Nasal initialization: " <<
- "short count returned from fread(). Check your C library!");
+ "short count returned from fread() of " << file <<
+ ". Check your C library!");
delete[] buf;
return 0;
}
{
_context = 0;
_globals = naNil();
- _timerHash = naNil();
- _nextTimerHashKey = 0; // Any value will do
+ _gcHash = naNil();
+ _nextGCKey = 0; // Any value will do
}
FGNasalSys::~FGNasalSys()
_globals = naNil();
}
+bool FGNasalSys::parseAndRun(const char* sourceCode)
+{
+ naRef code = parse("FGNasalSys::parseAndRun()", sourceCode,
+ strlen(sourceCode));
+ if(naIsNil(code))
+ return false;
+
+ naCall(_context, code, 0, 0, naNil(), naNil());
+
+ if(!naGetError(_context)) return true;
+ logError();
+ return false;
+}
+
+FGNasalScript* FGNasalSys::parseScript(const char* src, const char* name)
+{
+ FGNasalScript* script = new FGNasalScript();
+ script->_gcKey = -1; // important, if we delete it on a parse
+ script->_nas = this; // error, don't clobber a real handle!
+
+ char buf[256];
+ if(!name) {
+ sprintf(buf, "FGNasalScript@%p", script);
+ name = buf;
+ }
+
+ script->_code = parse(name, src, strlen(src));
+ if(naIsNil(script->_code)) {
+ delete script;
+ return 0;
+ }
+
+ script->_gcKey = gcSave(script->_code);
+ return script;
+}
+
// Utility. Sets a named key in a hash by C string, rather than nasal
// string object.
void FGNasalSys::hashset(naRef hash, const char* key, naRef val)
// 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)
{
SGPropertyNode* p = globals->get_props();
for(int i=0; i<len; i++) {
- naRef a = naVec_get(vec, i);
+ naRef a = vec[i];
if(!naIsString(a)) return 0;
p = p->getNode(naStr_data(a));
if(p == 0) return 0;
// getprop() extension function. Concatenates its string arguments as
// property names and returns the value of the specified property. Or
// nil if it doesn't exist.
-static naRef f_getprop(naContext c, naRef args)
+static naRef f_getprop(naContext c, naRef me, int argc, naRef* args)
{
- const SGPropertyNode* p = findnode(c, args, naVec_size(args));
+ const SGPropertyNode* p = findnode(c, args, argc);
if(!p) return naNil();
switch(p->getType()) {
return naNum(p->getDoubleValue());
case SGPropertyNode::STRING:
+ case SGPropertyNode::UNSPECIFIED:
{
naRef nastr = naNewString(c);
const char* val = p->getStringValue();
naStr_fromdata(nastr, (char*)val, strlen(val));
return nastr;
}
+ case SGPropertyNode::ALIAS: // <--- FIXME, recurse?
default:
return naNil();
}
// setprop() extension function. Concatenates its string arguments as
// property names and sets the value of the specified property to the
// final argument.
-static naRef f_setprop(naContext c, naRef args)
+static naRef f_setprop(naContext c, naRef me, int argc, naRef* args)
{
#define BUFLEN 1024
- int argc = naVec_size(args);
char buf[BUFLEN + 1];
buf[BUFLEN] = 0;
char* p = buf;
int buflen = BUFLEN;
for(int i=0; i<argc-1; i++) {
- naRef s = naStringValue(c, naVec_get(args, i));
+ naRef s = naStringValue(c, args[i]);
if(naIsNil(s)) return naNil();
strncpy(p, naStr_data(s), buflen);
p += naStr_len(s);
}
SGPropertyNode* props = globals->get_props();
- naRef val = naVec_get(args, argc-1);
+ naRef val = args[argc-1];
if(naIsString(val)) props->setStringValue(buf, naStr_data(val));
else props->setDoubleValue(buf, naNumValue(val).num);
return naNil();
// print() extension function. Concatenates and prints its arguments
// to the FlightGear log. Uses the highest log level (SG_ALERT), to
// make sure it appears. Is there better way to do this?
-static naRef f_print(naContext c, naRef args)
+static naRef f_print(naContext c, naRef me, int argc, naRef* args)
{
#define BUFLEN 1024
char buf[BUFLEN + 1];
buf[BUFLEN] = 0; // extra nul to handle strncpy brain damage
+ buf[0] = 0; // Zero-length in case there are no arguments
char* p = buf;
int buflen = BUFLEN;
- int n = naVec_size(args);
+ int n = argc;
for(int i=0; i<n; i++) {
- naRef s = naStringValue(c, naVec_get(args, i));
+ naRef s = naStringValue(c, args[i]);
if(naIsNil(s)) continue;
strncpy(p, naStr_data(s), buflen);
p += naStr_len(s);
// fgcommand() extension function. Executes a named command via the
// FlightGear command manager. Takes a single property node name as
// an argument.
-static naRef f_fgcommand(naContext c, naRef args)
+static naRef f_fgcommand(naContext c, naRef me, int argc, naRef* args)
{
- naRef cmd = naVec_get(args, 0);
- naRef props = naVec_get(args, 1);
- if(!naIsString(cmd) || !naIsString(props)) return naNil();
-
- SGPropertyNode* pnode =
- globals->get_props()->getNode(naStr_data(props));
- if(pnode)
- globals->get_commands()->execute(naStr_data(cmd), pnode);
+ if(argc < 2 || !naIsString(args[0]) || !naIsGhost(args[1]))
+ naRuntimeError(c, "bad arguments to fgcommand()");
+ naRef cmd = args[0], props = args[1];
+ SGPropertyNode_ptr* node = (SGPropertyNode_ptr*)naGhost_ptr(props);
+ globals->get_commands()->execute(naStr_data(cmd), *node);
return naNil();
+
}
// settimer(func, dt, simtime) extension function. Falls through to
// FGNasalSys::setTimer(). See there for docs.
-static naRef f_settimer(naContext c, naRef args)
+static naRef f_settimer(naContext c, naRef me, int argc, naRef* args)
+{
+ FGNasalSys* nasal = (FGNasalSys*)globals->get_subsystem("nasal");
+ nasal->setTimer(argc, args);
+ return naNil();
+}
+
+// Returns a ghost handle to the argument to the currently executing
+// command
+static naRef f_cmdarg(naContext c, naRef me, int argc, naRef* args)
{
FGNasalSys* nasal = (FGNasalSys*)globals->get_subsystem("nasal");
- nasal->setTimer(args);
+ return nasal->cmdArgGhost();
+}
+
+// Sets up a property interpolation. The first argument is either a
+// ghost (SGPropertyNode_ptr*) or a string (global property path) to
+// interpolate. The second argument is a vector of pairs of
+// value/delta numbers.
+static naRef f_interpolate(naContext c, naRef me, int argc, naRef* args)
+{
+ SGPropertyNode* node;
+ naRef prop = argc > 0 ? args[0] : naNil();
+ if(naIsString(prop)) node = fgGetNode(naStr_data(prop), true);
+ else if(naIsGhost(prop)) node = *(SGPropertyNode_ptr*)naGhost_ptr(prop);
+ else return naNil();
+
+ naRef curve = argc > 1 ? args[1] : naNil();
+ if(!naIsVector(curve)) return naNil();
+ int nPoints = naVec_size(curve) / 2;
+ double* values = new double[nPoints];
+ double* deltas = new double[nPoints];
+ for(int i=0; i<nPoints; i++) {
+ values[i] = naNumValue(naVec_get(curve, 2*i)).num;
+ deltas[i] = naNumValue(naVec_get(curve, 2*i+1)).num;
+ }
+
+ ((SGInterpolator*)globals->get_subsystem("interpolator"))
+ ->interpolate(node, nPoints, values, deltas);
+
return naNil();
}
+// This is a better RNG than the one in the default Nasal distribution
+// (which is based on the C library rand() implementation). It will
+// override.
+static naRef f_rand(naContext c, naRef me, int argc, naRef* args)
+{
+ return naNum(sg_random());
+}
+
// Table of extension functions. Terminate with zeros.
static struct { char* name; naCFunction func; } funcs[] = {
{ "getprop", f_getprop },
{ "setprop", f_setprop },
{ "print", f_print },
- { "fgcommand", f_fgcommand },
+ { "_fgcommand", f_fgcommand },
{ "settimer", f_settimer },
+ { "_cmdarg", f_cmdarg },
+ { "_interpolate", f_interpolate },
+ { "rand", f_rand },
{ 0, 0 }
};
+naRef FGNasalSys::cmdArgGhost()
+{
+ return propNodeGhost(_cmdArg);
+}
+
void FGNasalSys::init()
{
+ int i;
+
_context = naNewContext();
// Start with globals. Add it to itself as a recursive
hashset(_globals, "math", naMathLib(_context));
// Add our custom extension functions:
- for(int i=0; funcs[i].name; i++)
+ for(i=0; funcs[i].name; i++)
hashset(_globals, funcs[i].name,
naNewFunc(_context, naNewCCode(_context, funcs[i].func)));
- // Make a "__timers" hash to hold the settimer() handlers (to
- // protect them from begin garbage-collected).
- _timerHash = naNewHash(_context);
- hashset(_globals, "__timers", _timerHash);
+ // 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);
// Now load the various source files in the Nasal directory
SGPath p(globals->get_fg_root());
fullpath.append(dent->d_name);
SGPath file(dent->d_name);
if(file.extension() != "nas") continue;
- readScriptFile(fullpath, file.base().c_str());
+ loadModule(fullpath, file.base().c_str());
+ }
+
+ // Pull scripts out of the property tree, too
+ loadPropertyScripts();
+}
+
+// Loads the scripts found under /nasal in the global tree
+void FGNasalSys::loadPropertyScripts()
+{
+ SGPropertyNode* nasal = globals->get_props()->getNode("nasal");
+ if(!nasal) return;
+
+ for(int i=0; i<nasal->nChildren(); i++) {
+ SGPropertyNode* n = nasal->getChild(i);
+
+ const char* module = n->getName();
+ if(n->hasChild("module"))
+ module = n->getStringValue("module");
+
+ // allow multiple files to be specified within in a single
+ // Nasal module tag
+ int j = 0;
+ SGPropertyNode *fn;
+ bool file_specified = false;
+ while ( (fn = n->getChild("file", j)) != NULL ) {
+ file_specified = true;
+ const char* file = fn->getStringValue();
+ SGPath p(globals->get_fg_root());
+ p.append(file);
+ loadModule(p, module);
+ j++;
+ }
+
+ // Old code which only allowed a single file to be specified per module
+ /*
+ const char* file = n->getStringValue("file");
+ if(!n->hasChild("file")) file = 0; // Hrm...
+ if(file) {
+ SGPath p(globals->get_fg_root());
+ p.append(file);
+ loadModule(p, module);
+ }
+ */
+
+ const char* src = n->getStringValue("script");
+ if(!n->hasChild("script")) src = 0; // Hrm...
+ if(src)
+ createModule(module, n->getPath(), src, strlen(src));
+
+ if(!file_specified && !src)
+ SG_LOG(SG_NASAL, SG_ALERT, "Nasal error: " <<
+ "no <file> or <script> defined in " <<
+ "/nasal/" << module);
}
}
// Reads a script file, executes it, and places the resulting
// namespace into the global namespace under the specified module
// name.
-void FGNasalSys::readScriptFile(SGPath file, const char* lib)
+void FGNasalSys::loadModule(SGPath file, const char* module)
{
int len = 0;
char* buf = readfile(file.c_str(), &len);
- if(!buf) return;
+ if(!buf) {
+ SG_LOG(SG_NASAL, SG_ALERT,
+ "Nasal error: could not read script file " << file.c_str()
+ << " into module " << module);
+ return;
+ }
- // Parse and run. Save the local variables namespace, as it will
- // become a sub-object of globals.
- naRef code = parse(file.c_str(), buf, len);
+ createModule(module, file.c_str(), buf, len);
delete[] buf;
+}
+
+// Parse and run. Save the local variables namespace, as it will
+// become a sub-object of globals.
+void FGNasalSys::createModule(const char* moduleName, const char* fileName,
+ const char* src, int len)
+{
+ naRef code = parse(fileName, src, len);
if(naIsNil(code))
return;
- naRef locals = naNewHash(_context);
- naCall(_context, code, naNil(), naNil(), locals);
+ // 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);
+ naStr_fromdata(modname, (char*)moduleName, strlen(moduleName));
+ if(!naHash_get(_globals, modname, &locals))
+ locals = naNewHash(_context);
+
+ naCall(_context, code, 0, 0, naNil(), locals);
if(naGetError(_context)) {
logError();
return;
}
-
- hashset(_globals, lib, locals);
+ hashset(_globals, moduleName, locals);
}
naRef FGNasalSys::parse(const char* filename, const char* buf, int len)
bool FGNasalSys::handleCommand(const SGPropertyNode* arg)
{
- // Parse the Nasal source. I'd love to use the property name of
- // the argument, but it's actually a *clone* of the original
- // location in the property tree. arg->getPath() returns an empty
- // string.
const char* nasal = arg->getStringValue("script");
- naRef code = parse("<command>", nasal, strlen(nasal));
+ const char* moduleName = arg->getStringValue("module");
+ naRef code = parse(arg->getPath(true), nasal, strlen(nasal));
if(naIsNil(code)) return false;
-
- // FIXME: Cache the just-created code object somewhere, but watch
- // for changes to the source in the property tree. Maybe store an
- // integer index into a Nasal vector in the original property
- // location?
- // Extract the "value" or "offset" arguments if present
naRef locals = naNil();
- if(arg->hasValue("value")) {
- locals = naNewHash(_context);
- hashset(locals, "value", naNum(arg->getDoubleValue("value")));
- } else if(arg->hasValue("offset")) {
- locals = naNewHash(_context);
- hashset(locals, "offset", naNum(arg->getDoubleValue("offset")));
+ if (moduleName[0]) {
+ naRef modname = naNewString(_context);
+ naStr_fromdata(modname, (char*)moduleName, strlen(moduleName));
+ if(!naHash_get(_globals, modname, &locals))
+ locals = naNewHash(_context);
}
+ // Cache the command argument for inspection via cmdarg(). For
+ // performance reasons, we won't bother with it if the invoked
+ // code doesn't need it.
+ _cmdArg = (SGPropertyNode*)arg;
// Call it!
- naRef result = naCall(_context, code, naNil(), naNil(), locals);
+ naRef result = naCall(_context, code, 0, 0, naNil(), locals);
if(!naGetError(_context)) return true;
logError();
return false;
// settimer(func, dt, simtime) extension function. The first argument
// is a Nasal function to call, the second is a delta time (from now),
// in seconds. The third, if present, is a boolean value indicating
-// that "simulator" time (rather than real time) is to be used.
+// that "real world" time (rather than simulator time) is to be used.
//
// Implementation note: the FGTimer objects don't live inside the
// garbage collector, so the Nasal handler functions have to be
// "saved" somehow lest they be inadvertently cleaned. In this case,
-// they are inserted into a globals._timers hash and removed on
+// they are inserted into a globals.__gcsave hash and removed on
// expiration.
-void FGNasalSys::setTimer(naRef args)
+void FGNasalSys::setTimer(int argc, naRef* args)
{
// Extract the handler, delta, and simtime arguments:
- naRef handler = naVec_get(args, 0);
+ naRef handler = argc > 0 ? args[0] : naNil();
if(!(naIsCode(handler) || naIsCCode(handler) || naIsFunc(handler)))
return;
- naRef delta = naNumValue(naVec_get(args, 1));
+ naRef delta = argc > 1 ? args[1] : naNil();
if(naIsNil(delta)) return;
- bool simtime = naTrue(naVec_get(args, 2)) ? true : false;
+ bool simtime = (argc > 2 && naTrue(args[2])) ? false : true;
// Generate and register a C++ timer handler
NasalTimer* t = new NasalTimer;
t->handler = handler;
- t->hashKey = _nextTimerHashKey++;
+ t->gcKey = gcSave(handler);
t->nasal = this;
globals->get_event_mgr()->addEvent("NasalTimer",
t, &NasalTimer::timerExpired,
delta.num, simtime);
+}
+void FGNasalSys::handleTimer(NasalTimer* t)
+{
+ naCall(_context, t->handler, 0, 0, naNil(), naNil());
+ if(naGetError(_context))
+ logError();
+ gcRelease(t->gcKey);
+}
- // Save the handler in the globals.__timers hash to prevent
- // garbage collection.
- naHash_set(_timerHash, naNum(t->hashKey), handler);
+int FGNasalSys::gcSave(naRef r)
+{
+ int key = _nextGCKey++;
+ naHash_set(_gcHash, naNum(key), r);
+ return key;
}
-void FGNasalSys::handleTimer(NasalTimer* t)
+void FGNasalSys::gcRelease(int key)
{
- naCall(_context, t->handler, naNil(), naNil(), naNil());
- naHash_delete(_timerHash, naNum(t->hashKey));
+ naHash_delete(_gcHash, naNum(key));
}
void FGNasalSys::NasalTimer::timerExpired()
projects / flightgear.git / blobdiff