#include <Main/fg_props.hxx>
#include "NasalSys.hxx"
+#include "NasalDisplay.hxx"
// Read and return file contents in a single buffer. Note use of
// stat() to get the file size. This is a win32 function, believe it
if(naIsNil(code))
return false;
- naCall(_context, code, naNil(), naNil(), naNil());
+ naCall(_context, code, 0, 0, naNil(), naNil());
if(!naGetError(_context)) return true;
logError();
char buf[256];
if(!name) {
- sprintf(buf, "FGNasalScript@%8.8x", (int)script);
+ sprintf(buf, "FGNasalScript@%p", script);
name = buf;
}
- script->_code = parse(name, src);
+ script->_code = parse(name, src, strlen(src));
if(naIsNil(script->_code)) {
delete script;
return 0;
// 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) || !naIsGhost(props)) return naNil();
+ 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(args);
+ nasal->setTimer(argc, args);
+ return naNil();
+}
+
+// setlistener(func, property) extension function. Falls through to
+// FGNasalSys::setListener(). See there for docs.
+static naRef f_setlistener(naContext c, naRef me, int argc, naRef* args)
+{
+ FGNasalSys* nasal = (FGNasalSys*)globals->get_subsystem("nasal");
+ nasal->setListener(argc, args);
return naNil();
}
// Returns a ghost handle to the argument to the currently executing
// command
-static naRef f_cmdarg(naContext c, naRef args)
+static naRef f_cmdarg(naContext c, naRef me, int argc, naRef* args)
{
FGNasalSys* nasal = (FGNasalSys*)globals->get_subsystem("nasal");
return nasal->cmdArgGhost();
// 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 args)
+static naRef f_interpolate(naContext c, naRef me, int argc, naRef* args)
{
SGPropertyNode* node;
- naRef prop = naVec_get(args, 0);
+ 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 = naVec_get(args, 1);
+ naRef curve = argc > 1 ? args[1] : naNil();
if(!naIsVector(curve)) return naNil();
int nPoints = naVec_size(curve) / 2;
double* values = new double[nPoints];
((SGInterpolator*)globals->get_subsystem("interpolator"))
->interpolate(node, nPoints, values, deltas);
+
+ return naNil();
}
-static naRef f_rand(naContext c, naRef args)
+// 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());
}
+static naRef f_srand(naContext c, naRef me, int argc, naRef* args)
+{
+ sg_srandom_time();
+ return naNum(0);
+}
+
+// Wrapper function for screenPrint
+static naRef f_screenPrint(naContext c, naRef me, int argc, naRef* args)
+{
+ if(argc != 1 || !naIsString(args[0]))
+ naRuntimeError(c, "bad arguments to screenPrint()");
+ naRef lmsg = args[0];
+ FGNasalSys* nasal = (FGNasalSys*)globals->get_subsystem("nasal");
+ nasal->screenPrint(naStr_data(lmsg));
+ return naNil();
+}
+
+// Return an array listing of all files in a directory
+static naRef f_directory(naContext c, naRef me, int argc, naRef* args)
+{
+ if(argc != 1 || !naIsString(args[0]))
+ naRuntimeError(c, "bad arguments to directory()");
+ naRef ldir = args[0];
+ ulDir* dir = ulOpenDir(naStr_data(args[0]));
+ if(!dir) return naNil();
+ naRef result = naNewVector(c);
+ ulDirEnt* dent;
+ while((dent = ulReadDir(dir)))
+ naVec_append(result, naStr_fromdata(naNewString(c), dent->d_name,
+ strlen(dent->d_name)));
+ ulCloseDir(dir);
+ return result;
+}
+
// Table of extension functions. Terminate with zeros.
static struct { char* name; naCFunction func; } funcs[] = {
{ "getprop", f_getprop },
{ "print", f_print },
{ "_fgcommand", f_fgcommand },
{ "settimer", f_settimer },
+ { "_setlistener", f_setlistener },
{ "_cmdarg", f_cmdarg },
{ "_interpolate", f_interpolate },
{ "rand", f_rand },
+ { "srand", f_srand },
+ { "screenPrint", f_screenPrint },
+ { "directory", f_directory },
{ 0, 0 }
};
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
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);
- readScriptFile(p, module);
+ loadModule(p, module);
}
+ */
const char* src = n->getStringValue("script");
if(!n->hasChild("script")) src = 0; // Hrm...
if(src)
- initModule(module, n->getPath(), src, strlen(src));
+ createModule(module, n->getPath(), src, strlen(src));
- if(!file && !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* module)
+void FGNasalSys::loadModule(SGPath file, const char* module)
{
int len = 0;
char* buf = readfile(file.c_str(), &len);
return;
}
- initModule(module, 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::initModule(const char* moduleName, const char* fileName,
- const char* src, int len)
+void FGNasalSys::createModule(const char* moduleName, const char* fileName,
+ const char* src, int len)
{
- if(len == 0) len = strlen(src);
-
naRef code = parse(fileName, src, len);
if(naIsNil(code))
return;
if(!naHash_get(_globals, modname, &locals))
locals = naNewHash(_context);
- naCall(_context, code, naNil(), naNil(), locals);
+ naCall(_context, code, 0, 0, naNil(), locals);
if(naGetError(_context)) {
logError();
return;
naRef FGNasalSys::parse(const char* filename, const char* buf, int len)
{
- if(len == 0) len = strlen(buf);
int errLine = -1;
naRef srcfile = naNewString(_context);
naStr_fromdata(srcfile, (char*)filename, strlen(filename));
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);
+ const char* moduleName = arg->getStringValue("module");
+ naRef code = parse(arg->getPath(true), nasal, strlen(nasal));
if(naIsNil(code)) return false;
-
+
+ naRef locals = naNil();
+ 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(), naNil());
+ 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.__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;
void FGNasalSys::handleTimer(NasalTimer* t)
{
- naCall(_context, t->handler, naNil(), naNil(), naNil());
+ naCall(_context, t->handler, 0, 0, naNil(), naNil());
+ if(naGetError(_context))
+ logError();
gcRelease(t->gcKey);
}
nasal->handleTimer(this);
delete this;
}
+
+// setlistener(property, func) extension function. The first argument
+// is either a ghost (SGPropertyNode_ptr*) or a string (global property
+// path), the second is a Nasal function.
+void FGNasalSys::setListener(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;
+
+ naRef handler = argc > 1 ? args[1] : naNil();
+ if(!(naIsCode(handler) || naIsCCode(handler) || naIsFunc(handler)))
+ return;
+
+ node->addChangeListener(new FGNasalListener(handler, this, gcSave(handler)));
+}
+
+// functions providing access to the NasalDisplay - used to display text directly on the screen
+void FGNasalSys::screenPrint(const char* src)
+{
+ globals->get_Nasal_display()->RegisterSingleMessage(src, 0);
+}
projects / flightgear.git / blobdiff