s.length());
}
+static bool convertToNum(naRef v, double& result)
+{
+ naRef n = naNumValue(v);
+ if (naIsNil(n)) {
+ return false; // couldn't convert
+ }
+
+ result = n.num;
+ return true;
+}
+
static WayptFlag wayptFlagFromString(const char* s)
{
if (!strcmp(s, "sid")) return WPT_DEPARTURE;
static const char* waypointCommonGetMember(naContext c, Waypt* wpt, const char* fieldName, naRef* out)
{
- if (!strcmp(fieldName, "wp_name")) *out = stringToNasal(c, wpt->ident());
+ if (!strcmp(fieldName, "wp_name") || !strcmp(fieldName, "id")) *out = stringToNasal(c, wpt->ident());
else if (!strcmp(fieldName, "wp_type")) *out = stringToNasal(c, wpt->type());
else if (!strcmp(fieldName, "wp_role")) *out = wayptFlagToNasal(c, wpt->flags());
- else if (!strcmp(fieldName, "wp_lat")) *out = naNum(wpt->position().getLatitudeDeg());
- else if (!strcmp(fieldName, "wp_lon")) *out = naNum(wpt->position().getLongitudeDeg());
+ else if (!strcmp(fieldName, "wp_lat") || !strcmp(fieldName, "lat")) *out = naNum(wpt->position().getLatitudeDeg());
+ else if (!strcmp(fieldName, "wp_lon") || !strcmp(fieldName, "lon")) *out = naNum(wpt->position().getLongitudeDeg());
else if (!strcmp(fieldName, "wp_parent_name")) {
Procedure* proc = dynamic_cast<Procedure*>(wpt->owner());
*out = proc ? stringToNasal(c, proc->ident()) : naNil();
if (!strcmp(fieldName, "parents")) {
*out = naNewVector(c);
naVec_append(*out, fpLegPrototype);
+ naVec_append(*out, waypointPrototype);
} else if (!strcmp(fieldName, "index")) {
*out = naNum(leg->index());
} else if (!strcmp(fieldName, "alt_cstr")) {
return;
}
+ if (naIsNil(value)) {
+ fp->setDeparture(static_cast<FGAirport*>(NULL));
+ return;
+ }
+
naRuntimeError(c, "bad argument type setting departure");
} else if (!strcmp(fieldName, "destination")) {
FGAirport* apt = airportGhost(value);
return;
}
- naRuntimeError(c, "bad argument type setting departure");
+ naRuntimeError(c, "bad argument type setting departure runway");
} else if (!strcmp(fieldName, "destination_runway")) {
FGRunway* rwy = runwayGhost(value);
if (rwy){
return;
}
- naRuntimeError(c, "bad argument type setting departure");
+ naRuntimeError(c, "bad argument type setting destination runway");
} else if (!strcmp(fieldName, "sid")) {
Procedure* proc = procedureGhost(value);
if (proc && (proc->type() == PROCEDURE_SID)) {
naRef comms = naNewVector(c);
// if we have an explicit type, return a simple vector of frequencies
- if (argc > 0 && naIsScalar(args[0])) {
+ if (argc > 0 && !naIsString(args[0])) {
+ naRuntimeError(c, "airport.comms argument must be a frequency type name");
+ }
+
+ if (argc > 0) {
std::string commName = naStr_data(args[0]);
FGPositioned::Type commType = FGPositioned::typeFromName(commName);
return ghostForProcedure(c, apt->findApproachWithIdent(ident));
}
+static naRef f_airport_findBestRunway(naContext c, naRef me, int argc, naRef* args)
+{
+ FGAirport* apt = airportGhost(me);
+ if (!apt) {
+ naRuntimeError(c, "findBestRunway called on non-airport object");
+ }
+
+ SGGeod pos;
+ if (!geodFromArgs(args, 0, argc, pos)) {
+ naRuntimeError(c, "findBestRunway must be passed a position");
+ }
+
+ return ghostForRunway(c, apt->findBestRunwayForPos(pos));
+}
+
static naRef f_airport_toString(naContext c, naRef me, int argc, naRef* args)
{
FGAirport* apt = airportGhost(me);
_plan(fp),
_instance(ins)
{
- SG_LOG(SG_NASAL, SG_INFO, "created Nasal delegate for " << fp);
_gcSaveKey = _nasal->gcSave(ins);
}
virtual ~NasalFPDelegate()
{
- SG_LOG(SG_NASAL, SG_INFO, "destroying Nasal delegate for " << _plan);
_nasal->gcRelease(_gcSaveKey);
}
{
callDelegateMethod("cleared");
}
+
+ virtual void endOfFlightPlan()
+ {
+ callDelegateMethod("endOfFlightPlan");
+ }
private:
void callDelegateMethod(const char* method)
{
naRef f;
- naMember_cget(_nasal->context(), _instance, method, &f);
- if (naIsNil(f)) {
+ if (naMember_cget(_nasal->context(), _instance, method, &f) == 0) {
return; // no method on the delegate
}
// set waypt flags - approach, departure, pseudo, etc
if (argc > argOffset) {
WayptFlag f = wayptFlagFromString(naStr_data(args[argOffset++]));
+ if (f == 0) {
+ naRuntimeError(c, "createWP: bad waypoint role");
+ }
+
wpt->setFlag(f);
}
// set waypt flags - approach, departure, pseudo, etc
if (argc > 1) {
WayptFlag f = wayptFlagFromString(naStr_data(args[1]));
+ if (f == 0) {
+ naRuntimeError(c, "createWPFrom: bad waypoint role");
+ }
wpt->setFlag(f);
}
}
WayptFlag flag = wayptFlagFromString(naStr_data(args[0]));
+ if (flag == 0) {
+ naRuntimeError(c, "clearWPType: bad waypoint role");
+ }
+
fp->clearWayptsWithFlag(flag);
return naNil();
}
return result;
}
+static naRef f_flightplan_finish(naContext c, naRef me, int argc, naRef* args)
+{
+ FlightPlan* fp = flightplanGhost(me);
+ if (!fp) {
+ naRuntimeError(c, "flightplan.finish called on non-flightplan object");
+ }
+
+ fp->finish();
+ return naNil();
+}
static naRef f_leg_setSpeed(naContext c, naRef me, int argc, naRef* args)
{
if (!leg) {
naRuntimeError(c, "leg.setSpeed called on non-flightplan-leg object");
}
-
- if (argc < 2) {
- naRuntimeError(c, "bad arguments to leg.setSpeed");
- }
-
+
+ double speed = 0.0;
+ if ((argc < 2) || !convertToNum(args[0], speed))
+ naRuntimeError(c, "bad arguments to setSpeed");
+
RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
- leg->setSpeed(rr, args[0].num);
+ leg->setSpeed(rr, speed);
+
return naNil();
}
naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
}
- if (argc < 2) {
- naRuntimeError(c, "bad arguments to leg.setAltitude");
- }
-
+ double alt = 0.0;
+ if ((argc < 2) || !convertToNum(args[0], alt))
+ naRuntimeError(c, "bad arguments to leg.setAltitude");
+
RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
- leg->setAltitude(rr, args[0].num);
+ leg->setAltitude(rr, alt);
+
return naNil();
}
};
-naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
+naRef initNasalPositioned(naRef globals, naContext c)
{
airportPrototype = naNewHash(c);
- hashset(c, gcSave, "airportProto", airportPrototype);
+ naSave(c, airportPrototype);
hashset(c, airportPrototype, "runway", naNewFunc(c, naNewCCode(c, f_airport_runway)));
hashset(c, airportPrototype, "runwaysWithoutReciprocals", naNewFunc(c, naNewCCode(c, f_airport_runwaysWithoutReciprocals)));
hashset(c, airportPrototype, "getSid", naNewFunc(c, naNewCCode(c, f_airport_getSid)));
hashset(c, airportPrototype, "getStar", naNewFunc(c, naNewCCode(c, f_airport_getStar)));
hashset(c, airportPrototype, "getIAP", naNewFunc(c, naNewCCode(c, f_airport_getApproach)));
+ hashset(c, airportPrototype, "findBestRunwayForPos", naNewFunc(c, naNewCCode(c, f_airport_findBestRunway)));
hashset(c, airportPrototype, "tostring", naNewFunc(c, naNewCCode(c, f_airport_toString)));
flightplanPrototype = naNewHash(c);
- hashset(c, gcSave, "flightplanProto", flightplanPrototype);
+ naSave(c, flightplanPrototype);
hashset(c, flightplanPrototype, "getWP", naNewFunc(c, naNewCCode(c, f_flightplan_getWP)));
hashset(c, flightplanPrototype, "currentWP", naNewFunc(c, naNewCCode(c, f_flightplan_currentWP)));
hashset(c, flightplanPrototype, "clearWPType", naNewFunc(c, naNewCCode(c, f_flightplan_clearWPType)));
hashset(c, flightplanPrototype, "clone", naNewFunc(c, naNewCCode(c, f_flightplan_clone)));
hashset(c, flightplanPrototype, "pathGeod", naNewFunc(c, naNewCCode(c, f_flightplan_pathGeod)));
+ hashset(c, flightplanPrototype, "finish", naNewFunc(c, naNewCCode(c, f_flightplan_finish)));
waypointPrototype = naNewHash(c);
- hashset(c, gcSave, "wayptProto", waypointPrototype);
+ naSave(c, waypointPrototype);
hashset(c, waypointPrototype, "navaid", naNewFunc(c, naNewCCode(c, f_waypoint_navaid)));
hashset(c, waypointPrototype, "runway", naNewFunc(c, naNewCCode(c, f_waypoint_runway)));
hashset(c, waypointPrototype, "airport", naNewFunc(c, naNewCCode(c, f_waypoint_airport)));
procedurePrototype = naNewHash(c);
- hashset(c, gcSave, "procedureProto", procedurePrototype);
+ naSave(c, procedurePrototype);
hashset(c, procedurePrototype, "transition", naNewFunc(c, naNewCCode(c, f_procedure_transition)));
hashset(c, procedurePrototype, "route", naNewFunc(c, naNewCCode(c, f_procedure_route)));
fpLegPrototype = naNewHash(c);
- hashset(c, gcSave, "fpLegProto", fpLegPrototype);
+ naSave(c, fpLegPrototype);
hashset(c, fpLegPrototype, "setSpeed", naNewFunc(c, naNewCCode(c, f_leg_setSpeed)));
hashset(c, fpLegPrototype, "setAltitude", naNewFunc(c, naNewCCode(c, f_leg_setAltitude)));
hashset(c, fpLegPrototype, "path", naNewFunc(c, naNewCCode(c, f_leg_path)));