X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FScripting%2FNasalSys.cxx;h=870d6def1455f0831e095243af62223d333bb799;hb=9c28ed02577e6d32e1365567107adbd048f3d743;hp=e481ac510a5f0384a73dadbe4baa4c7efa4b6136;hpb=d3181fb437818a9b333eac85c4afcef1335bf8b6;p=flightgear.git

diff --git a/src/Scripting/NasalSys.cxx b/src/Scripting/NasalSys.cxx
index e481ac510..870d6def1 100644
--- a/src/Scripting/NasalSys.cxx
+++ b/src/Scripting/NasalSys.cxx
@@ -7,10 +7,13 @@
 
 #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"
 
@@ -34,7 +37,8 @@ static char* readfile(const char* file, int* lenOut)
         // 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;
     }
@@ -45,8 +49,8 @@ FGNasalSys::FGNasalSys()
 {
     _context = 0;
     _globals = naNil();
-    _timerHash = naNil();
-    _nextTimerHashKey = 0; // Any value will do
+    _gcHash = naNil();
+    _nextGCKey = 0; // Any value will do
 }
 
 FGNasalSys::~FGNasalSys()
@@ -60,6 +64,42 @@ 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)
@@ -76,11 +116,11 @@ 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;
@@ -91,9 +131,9 @@ static SGPropertyNode* findnode(naContext c, naRef vec, int len)
 // 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()) {
@@ -103,12 +143,14 @@ static naRef f_getprop(naContext c, naRef args)
         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();
     }
@@ -117,16 +159,15 @@ static naRef f_getprop(naContext c, naRef args)
 // 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);
@@ -138,7 +179,7 @@ static naRef f_setprop(naContext c, naRef args)
     }
 
     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();
@@ -148,16 +189,17 @@ static naRef f_setprop(naContext c, naRef args)
 // 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);
@@ -172,40 +214,92 @@ static naRef f_print(naContext c, naRef args)
 // 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
@@ -220,14 +314,18 @@ void FGNasalSys::init()
     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());
@@ -239,7 +337,60 @@ void FGNasalSys::init()
         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);
     }
 }
 
@@ -260,27 +411,45 @@ void FGNasalSys::logError()
 // 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)
@@ -302,31 +471,25 @@ 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;
@@ -335,45 +498,54 @@ bool FGNasalSys::handleCommand(const SGPropertyNode* arg)
 // 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()