X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FScripting%2FNasalPositioned.cxx;h=66bfb5826a370b55bf7af5642dbdf78096d6baf3;hb=12076bce0e9fb66286f14931e8f4eb12fc0b9b82;hp=031e85f1f64c101752c57052d1370a5d319076e2;hpb=acd8fa25e655ddd647413386f778032c92db94de;p=flightgear.git

diff --git a/src/Scripting/NasalPositioned.cxx b/src/Scripting/NasalPositioned.cxx
index 031e85f1f..66bfb5826 100644
--- a/src/Scripting/NasalPositioned.cxx
+++ b/src/Scripting/NasalPositioned.cxx
@@ -39,18 +39,21 @@
 #include <Airports/simple.hxx>
 #include <Airports/dynamics.hxx>
 #include <Airports/parking.hxx>
+#include <Scripting/NasalSys.hxx>
 #include <Navaids/navlist.hxx>
 #include <Navaids/procedure.hxx>
 #include <Main/globals.hxx>
 #include <Main/fg_props.hxx>
 #include <Scenery/scenery.hxx>
 #include <ATC/CommStation.hxx>
-#include <Navaids/route.hxx>
+#include <Navaids/FlightPlan.hxx>
 #include <Navaids/waypoint.hxx>
 #include <Navaids/fix.hxx>
 #include <Autopilot/route_mgr.hxx>
+#include <Navaids/routePath.hxx>
 #include <Navaids/procedure.hxx>
 #include <Navaids/airways.hxx>
+#include <Navaids/NavDataCache.hxx>
 
 using namespace flightgear;
 
@@ -69,15 +72,18 @@ naGhostType NavaidGhostType = { positionedGhostDestroy, "navaid", navaidGhostGet
 
 static const char* runwayGhostGetMember(naContext c, void* g, naRef field, naRef* out);
 naGhostType RunwayGhostType = { positionedGhostDestroy, "runway", runwayGhostGetMember, 0 };
+naGhostType TaxiwayGhostType = { positionedGhostDestroy, "taxiway", runwayGhostGetMember, 0 };
 
 static const char* fixGhostGetMember(naContext c, void* g, naRef field, naRef* out);
 naGhostType FixGhostType = { positionedGhostDestroy, "fix", fixGhostGetMember, 0 };
 
 static const char* wayptGhostGetMember(naContext c, void* g, naRef field, naRef* out);
+static void waypointGhostSetMember(naContext c, void* g, naRef field, naRef value);
+
 naGhostType WayptGhostType = { wayptGhostDestroy, 
   "waypoint",
   wayptGhostGetMember,
-  0};
+  waypointGhostSetMember};
 
 static const char* legGhostGetMember(naContext c, void* g, naRef field, naRef* out);
 static void legGhostSetMember(naContext c, void* g, naRef field, naRef value);
@@ -171,6 +177,13 @@ static FGRunway* runwayGhost(naRef r)
   return 0;
 }
 
+static FGTaxiway* taxiwayGhost(naRef r)
+{
+  if (naGhost_type(r) == &TaxiwayGhostType)
+    return (FGTaxiway*) naGhost_ptr(r);
+  return 0;
+}
+
 static FGFix* fixGhost(naRef r)
 {
   if (naGhost_type(r) == &FixGhostType)
@@ -275,6 +288,16 @@ naRef ghostForRunway(naContext c, const FGRunway* r)
   return naNewGhost2(c, &RunwayGhostType, (void*) r);
 }
 
+naRef ghostForTaxiway(naContext c, const FGTaxiway* r)
+{
+  if (!r) {
+    return naNil();
+  }
+  
+  FGPositioned::get(r); // take a ref
+  return naNewGhost2(c, &TaxiwayGhostType, (void*) r);
+}
+
 naRef ghostForFix(naContext c, const FGFix* r)
 {
   if (!r) {
@@ -291,7 +314,7 @@ naRef ghostForWaypt(naContext c, const Waypt* wpt)
   if (!wpt) {
     return naNil();
   }
-  
+
   Waypt::get(wpt); // take a ref
   return naNewGhost2(c, &WayptGhostType, (void*) wpt);
 }
@@ -341,13 +364,28 @@ static const char* airportGhostGetMember(naContext c, void* g, naRef field, naRe
     *out = naNum(apt->getMetar());
   } else if (!strcmp(fieldName, "runways")) {
     *out = naNewHash(c);
+    double minLengthFt = fgGetDouble("/sim/navdb/min-runway-length-ft");
     for(unsigned int r=0; r<apt->numRunways(); ++r) {
       FGRunway* rwy(apt->getRunwayByIndex(r));
+      
+    // ignore unusably short runways
+      if (rwy->lengthFt() < minLengthFt) {
+        continue;
+      }
+      
       naRef rwyid = stringToNasal(c, rwy->ident());
       naRef rwydata = ghostForRunway(c, rwy);
       naHash_set(*out, rwyid, rwydata);
     }
 
+  } else if (!strcmp(fieldName, "taxiways")) {
+    *out = naNewVector(c);
+    for(unsigned int r=0; r<apt->numTaxiways(); ++r) {
+      FGTaxiway* taxi(apt->getTaxiwayByIndex(r));
+      naRef taxidata = ghostForTaxiway(c, taxi);
+      naVec_append(*out, taxidata);
+    }
+
   } else {
     return 0;
   }
@@ -381,6 +419,20 @@ static const char* waypointCommonGetMember(naContext c, Waypt* wpt, const char*
   return "";
 }
 
+static void waypointCommonSetMember(naContext c, Waypt* wpt, const char* fieldName, naRef value)
+{
+  if (!strcmp(fieldName, "wp_role")) {
+    if (!naIsString(value)) naRuntimeError(c, "wp_role must be a string");
+    if (wpt->owner() != NULL) naRuntimeError(c, "cannot override wp_role on waypoint with parent");
+    WayptFlag f = wayptFlagFromString(naStr_data(value));
+    if (f == 0) {
+      naRuntimeError(c, "unrecognized wp_role value %s", naStr_data(value));
+    }
+    
+    wpt->setFlag(f, true);
+  }
+}
+
 static const char* wayptGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 {
   const char* fieldName = naStr_data(field);
@@ -449,21 +501,19 @@ static const char* legGhostGetMember(naContext c, void* g, naRef field, naRef* o
   return ""; // success
 }
 
+static void waypointGhostSetMember(naContext c, void* g, naRef field, naRef value)
+{
+  const char* fieldName = naStr_data(field);
+  Waypt* wpt = (Waypt*) g;
+  waypointCommonSetMember(c, wpt, fieldName, value);
+}
+
 static void legGhostSetMember(naContext c, void* g, naRef field, naRef value)
 {
   const char* fieldName = naStr_data(field);
   FlightPlan::Leg* leg = (FlightPlan::Leg*) g;
-  
-  if (!strcmp(fieldName, "wp_role")) {
-    if (!naIsString(value)) naRuntimeError(c, "wp_role must be a string");
-    if (leg->waypoint()->owner() != NULL) naRuntimeError(c, "cannot override wp_role on waypoint with parent");
-    WayptFlag f = wayptFlagFromString(naStr_data(value));
-    if (f == 0) {
-      naRuntimeError(c, "unrecognized wp_role value %s", naStr_data(value));
-    }
     
-    leg->waypoint()->setFlag(f, true);
-  }
+  waypointCommonSetMember(c, leg->waypoint(), fieldName, value);
 }
 
 static const char* flightplanGhostGetMember(naContext c, void* g, naRef field, naRef* out)
@@ -647,7 +697,7 @@ static const char* procedureGhostGetMember(naContext c, void* g, naRef field, na
   else if (!strcmp(fieldName, "radio")) *out = procedureRadioType(c, proc->type());
   else if (!strcmp(fieldName, "runways")) {
     *out = naNewVector(c);
-    BOOST_FOREACH(FGRunwayPtr rwy, proc->runways()) {
+    BOOST_FOREACH(FGRunwayRef rwy, proc->runways()) {
       naVec_append(*out, stringToNasal(c, rwy->ident()));
     }
   } else if (!strcmp(fieldName, "transitions")) {
@@ -671,22 +721,28 @@ static const char* procedureGhostGetMember(naContext c, void* g, naRef field, na
 static const char* runwayGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 {
   const char* fieldName = naStr_data(field);
-  FGRunway* rwy = (FGRunway*) g;
-  
-  if (!strcmp(fieldName, "id")) *out = stringToNasal(c, rwy->ident());
-  else if (!strcmp(fieldName, "lat")) *out = naNum(rwy->latitude());
-  else if (!strcmp(fieldName, "lon")) *out = naNum(rwy->longitude());
-  else if (!strcmp(fieldName, "heading")) *out = naNum(rwy->headingDeg());
-  else if (!strcmp(fieldName, "length")) *out = naNum(rwy->lengthM());
-  else if (!strcmp(fieldName, "width")) *out = naNum(rwy->widthM());
-  else if (!strcmp(fieldName, "threshold")) *out = naNum(rwy->displacedThresholdM());
-  else if (!strcmp(fieldName, "stopway")) *out = naNum(rwy->stopwayM());
-  else if (!strcmp(fieldName, "ils_frequency_mhz")) {
-    *out = rwy->ILS() ? naNum(rwy->ILS()->get_freq() / 100.0) : naNil();
-  } else if (!strcmp(fieldName, "ils")) {
-    *out = ghostForNavaid(c, rwy->ILS());
+  FGRunwayBase* base = (FGRunwayBase*) g;
+  
+  if (!strcmp(fieldName, "id")) *out = stringToNasal(c, base->ident());
+  else if (!strcmp(fieldName, "lat")) *out = naNum(base->latitude());
+  else if (!strcmp(fieldName, "lon")) *out = naNum(base->longitude());
+  else if (!strcmp(fieldName, "heading")) *out = naNum(base->headingDeg());
+  else if (!strcmp(fieldName, "length")) *out = naNum(base->lengthM());
+  else if (!strcmp(fieldName, "width")) *out = naNum(base->widthM());
+  else if (!strcmp(fieldName, "surface")) *out = naNum(base->surface());
+  else if (base->type() == FGRunwayBase::RUNWAY) {  
+    FGRunway* rwy = (FGRunway*) g;
+    if (!strcmp(fieldName, "threshold")) *out = naNum(rwy->displacedThresholdM());
+    else if (!strcmp(fieldName, "stopway")) *out = naNum(rwy->stopwayM());
+    else if (!strcmp(fieldName, "ils_frequency_mhz")) {
+      *out = rwy->ILS() ? naNum(rwy->ILS()->get_freq() / 100.0) : naNil();
+    } else if (!strcmp(fieldName, "ils")) {
+      *out = ghostForNavaid(c, rwy->ILS());
+    } else {
+      return 0;
+    }
   } else {
-    return 0;
+    return 0;    
   }
   
   return "";
@@ -746,7 +802,7 @@ static bool hashIsCoord(naRef h)
     return false;
   }
   
-  return naEqual(naVec_get(parents, 0), geoCoordClass);
+  return naEqual(naVec_get(parents, 0), geoCoordClass) != 0;
 }
 
 bool geodFromHash(naRef ref, SGGeod& result)
@@ -802,6 +858,11 @@ static int geodFromArgs(naRef* args, int offset, int argc, SGGeod& result)
       return 1;
     }
     
+    if (gt == &TaxiwayGhostType) {
+      result = taxiwayGhost(args[offset])->geod();
+      return 1;
+    }
+    
     if (gt == &FixGhostType) {
       result = fixGhost(args[offset])->geod();
       return 1;
@@ -872,10 +933,11 @@ static naRef f_geodinfo(naContext c, naRef me, int argc, naRef* args)
   double lat = naNumValue(args[0]).num;
   double lon = naNumValue(args[1]).num;
   double elev = argc == 3 ? naNumValue(args[2]).num : 10000;
-  const SGMaterial *mat;
+  const simgear::BVHMaterial *material;
   SGGeod geod = SGGeod::fromDegM(lon, lat, elev);
-  if(!globals->get_scenery()->get_elevation_m(geod, elev, &mat))
+  if(!globals->get_scenery()->get_elevation_m(geod, elev, &material))
     return naNil();
+  const SGMaterial *mat = dynamic_cast<const SGMaterial *>(material);
   naRef vec = naNewVector(c);
   naVec_append(vec, naNum(elev));
   naRef matdata = naNil();
@@ -903,6 +965,7 @@ class AirportInfoFilter : public FGAirport::AirportFilter
 {
 public:
   AirportInfoFilter() : type(FGPositioned::AIRPORT) {
+    minRunwayLengthFt = fgGetDouble("/sim/navdb/min-runway-length-ft", 0.0);
   }
   
   bool fromArg(naRef arg)
@@ -924,8 +987,21 @@ public:
   virtual FGPositioned::Type maxType() const {
     return type;
   }
+    
+  virtual bool pass(FGPositioned* aPos) const
+  {
+    FGAirport* apt = (FGAirport*) aPos;
+    if ((apt->type() == FGPositioned::AIRPORT) && 
+        !apt->hasHardRunwayOfLengthFt(minRunwayLengthFt)) 
+    {
+      return false;
+    }
+
+    return true;
+  }
   
   FGPositioned::Type type;
+  double minRunwayLengthFt;
 };
 
 // Returns data hash for particular or nearest airport of a <type>, or nil
@@ -1097,6 +1173,26 @@ static naRef f_airport_runway(naContext c, naRef me, int argc, naRef* args)
   return ghostForRunway(c, apt->getRunwayByIdent(ident));
 }
 
+static naRef f_airport_taxiway(naContext c, naRef me, int argc, naRef* args)
+{
+  FGAirport* apt = airportGhost(me);
+  if (!apt) {
+    naRuntimeError(c, "airport.taxiway called on non-airport object");
+  }
+  
+  if ((argc < 1) || !naIsString(args[0])) {
+    naRuntimeError(c, "airport.taxiway expects a taxiway ident argument");
+  }
+  
+  naRef taxiways = naNewVector(c);
+  
+  for (unsigned int i = 0; i < apt->numTaxiways(); i++) {
+    naVec_append(taxiways, ghostForTaxiway(c, apt->getTaxiwayByIndex(i)));
+  }
+  
+  return taxiways;  
+}
+
 static naRef f_airport_sids(naContext c, naRef me, int argc, naRef* args)
 {
   FGAirport* apt = airportGhost(me);
@@ -1244,19 +1340,27 @@ static naRef f_airport_parking(naContext c, naRef me, int argc, naRef* args)
   }
   
   FGAirportDynamics* dynamics = apt->getDynamics();
-  for (int i=0; i<dynamics->getNrOfParkings(); ++i) {
-    FGParking* park = dynamics->getParking(i);
-  // filter out based on availability and type
-    if (onlyAvailable && !park->isAvailable()) {
+  PositionedIDVec parkings = flightgear::NavDataCache::instance()->airportItemsOfType(apt->guid(),
+                                                                                      FGPositioned::PARKING);
+  
+  BOOST_FOREACH(PositionedID parking, parkings) {
+    // filter out based on availability and type
+    if (onlyAvailable && !dynamics->isParkingAvailable(parking)) {
       continue;
     }
     
+    FGParking* park = dynamics->getParking(parking);
     if (!type.empty() && (park->getType() != type)) {
       continue;
     }
     
-    naRef nm = stringToNasal(c, park->getName());
-    naVec_append(r, nm);
+    const SGGeod& parkLoc = park->geod();
+    naRef ph = naNewHash(c);
+    hashset(c, ph, "name", stringToNasal(c, park->getName()));
+    hashset(c, ph, "lat", naNum(parkLoc.getLatitudeDeg()));
+    hashset(c, ph, "lon", naNum(parkLoc.getLongitudeDeg()));
+    hashset(c, ph, "elevation", naNum(parkLoc.getElevationM()));
+    naVec_append(r, ph);
   }
   
   return r;
@@ -1307,6 +1411,16 @@ static naRef f_airport_getApproach(naContext c, naRef me, int argc, naRef* args)
   return ghostForProcedure(c, apt->findApproachWithIdent(ident));
 }
 
+static naRef f_airport_toString(naContext c, naRef me, int argc, naRef* args)
+{
+  FGAirport* apt = airportGhost(me);
+  if (!apt) {
+    naRuntimeError(c, "airport.tostring called on non-airport object");
+  }
+  
+  return stringToNasal(c, "an airport " + apt->ident());
+}
+
 // Returns vector of data hash for navaid of a <type>, nil on error
 // navaids sorted by ascending distance 
 // navinfo([<lat>,<lon>],[<type>],[<id>])
@@ -1364,7 +1478,8 @@ static naRef f_navinfo(naContext c, naRef me, int argc, naRef* args)
     return naNil();
   }
   
-  navlist = globals->get_navlist()->findByIdentAndFreq( pos, id, 0.0, type );
+  FGNavList::TypeFilter filter(type);
+  navlist = FGNavList::findByIdentAndFreq( pos, id, 0.0, &filter );
   
   naRef reply = naNewVector(c);
   for( nav_list_type::const_iterator it = navlist.begin(); it != navlist.end(); ++it ) {
@@ -1418,7 +1533,8 @@ static naRef f_findNavaidByFrequency(naContext c, naRef me, int argc, naRef* arg
     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
   }
   
-  nav_list_type navs = globals->get_navlist()->findAllByFreq(freqMhz, pos, type);
+  FGNavList::TypeFilter filter(type);
+  nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
   if (navs.empty()) {
     return naNil();
   }
@@ -1443,7 +1559,9 @@ static naRef f_findNavaidsByFrequency(naContext c, naRef me, int argc, naRef* ar
   }
   
   naRef r = naNewVector(c);
-  nav_list_type navs = globals->get_navlist()->findAllByFreq(freqMhz, pos, type);
+  
+  FGNavList::TypeFilter filter(type);
+  nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
   
   BOOST_FOREACH(nav_rec_ptr a, navs) {
     naVec_append(r, ghostForNavaid(c, a.ptr()));
@@ -1468,8 +1586,9 @@ static naRef f_findNavaidsByIdent(naContext c, naRef me, int argc, naRef* args)
     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
   }
   
+  FGNavList::TypeFilter filter(type);
   naRef r = naNewVector(c);
-  nav_list_type navs = globals->get_navlist()->findByIdentAndFreq(pos, ident, 0.0, type);
+  nav_list_type navs = FGNavList::findByIdentAndFreq(pos, ident, 0.0, &filter);
   
   BOOST_FOREACH(nav_rec_ptr a, navs) {
     naVec_append(r, ghostForNavaid(c, a.ptr()));
@@ -1616,6 +1735,108 @@ static naRef f_route(naContext c, naRef me, int argc, naRef* args)
   return naNil();
 }
 
+class NasalFPDelegate : public FlightPlan::Delegate
+{
+public:
+  NasalFPDelegate(FlightPlan* fp, FGNasalSys* sys, naRef ins) :
+    _nasal(sys),
+    _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);
+  }
+  
+  virtual void departureChanged()
+  {
+    callDelegateMethod("departureChanged");
+  }
+  
+  virtual void arrivalChanged()
+  {
+    callDelegateMethod("arrivalChanged");
+  }
+  
+  virtual void waypointsChanged()
+  {
+    callDelegateMethod("waypointsChanged");
+  }
+  
+  virtual void currentWaypointChanged()
+  {
+    callDelegateMethod("currentWaypointChanged");
+  }
+private:
+  
+  void callDelegateMethod(const char* method)
+  {
+    naRef f;
+    naMember_cget(_nasal->context(), _instance, method, &f);
+    if (naIsNil(f)) {
+      return; // no method on the delegate
+    }
+    
+    naRef arg[1];
+    arg[0] = ghostForFlightPlan(_nasal->context(), _plan);
+    _nasal->callMethod(f, _instance, 1, arg, naNil());
+  }
+  
+  FGNasalSys* _nasal;
+  FlightPlan* _plan;
+  naRef _instance;
+  int _gcSaveKey;
+};
+
+class NasalFPDelegateFactory : public FlightPlan::DelegateFactory
+{
+public:
+  NasalFPDelegateFactory(naRef code)
+  {
+    _nasal = (FGNasalSys*) globals->get_subsystem("nasal");
+    _func = code;
+    _gcSaveKey = _nasal->gcSave(_func);
+  }
+  
+  ~NasalFPDelegateFactory()
+  {
+    _nasal->gcRelease(_gcSaveKey);
+  }
+  
+  virtual FlightPlan::Delegate* createFlightPlanDelegate(FlightPlan* fp)
+  {
+    naRef args[1];
+    args[0] = ghostForFlightPlan(_nasal->context(), fp);
+    naRef instance = _nasal->call(_func, 1, args, naNil());
+    if (naIsNil(instance)) {
+      return NULL;
+    }
+    
+    return new NasalFPDelegate(fp, _nasal, instance);
+  }
+private:
+  FGNasalSys* _nasal;
+  naRef _func;
+  int _gcSaveKey;
+};
+
+static naRef f_registerFPDelegate(naContext c, naRef me, int argc, naRef* args)
+{
+  if ((argc < 1) || !naIsFunc(args[0])) {
+    naRuntimeError(c, "non-function argument to registerFlightPlanDelegate");
+  }
+  
+  NasalFPDelegateFactory* factory = new NasalFPDelegateFactory(args[0]);
+  FlightPlan::registerDelegateFactory(factory);
+  
+  return naNil();
+}
+
 static WayptRef wayptFromArg(naRef arg)
 {
   WayptRef r = wayptGhost(arg);
@@ -1904,6 +2125,31 @@ static naRef f_flightplan_clone(naContext c, naRef me, int argc, naRef* args)
   return ghostForFlightPlan(c, fp->clone());
 }
 
+static naRef f_flightplan_pathGeod(naContext c, naRef me, int argc, naRef* args)
+{
+  FlightPlan* fp = flightplanGhost(me);
+  if (!fp) {
+    naRuntimeError(c, "flightplan.clone called on non-flightplan object");
+  }
+
+  if ((argc < 1) || !naIsNum(args[0])) {
+    naRuntimeError(c, "bad argument to flightplan.pathGeod");
+  }
+
+  if ((argc > 1) && !naIsNum(args[1])) {
+    naRuntimeError(c, "bad argument to flightplan.pathGeod");
+  }
+
+  int index = (int) args[0].num;
+  double offset = (argc > 1) ? args[1].num : 0.0;
+  naRef result = naNewHash(c);
+  SGGeod g = fp->pointAlongRoute(index, offset);
+  hashset(c, result, "lat", naNum(g.getLatitudeDeg()));
+  hashset(c, result, "lon", naNum(g.getLongitudeDeg()));
+  return result;
+}
+
+
 static naRef f_leg_setSpeed(naContext c, naRef me, int argc, naRef* args)
 {
   FlightPlan::Leg* leg = fpLegGhost(me);
@@ -1936,6 +2182,28 @@ static naRef f_leg_setAltitude(naContext c, naRef me, int argc, naRef* args)
   return naNil();
 }
 
+static naRef f_leg_path(naContext c, naRef me, int argc, naRef* args)
+{
+  FlightPlan::Leg* leg = fpLegGhost(me);
+  if (!leg) {
+    naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
+  }
+  
+  RoutePath path(leg->owner());
+  SGGeodVec gv(path.pathForIndex(leg->index()));
+
+  naRef result = naNewVector(c);
+  BOOST_FOREACH(SGGeod p, gv) {
+    // construct a geo.Coord!
+    naRef coord = naNewHash(c);
+    hashset(c, coord, "lat", naNum(p.getLatitudeDeg()));
+    hashset(c, coord, "lon", naNum(p.getLongitudeDeg()));
+    naVec_append(result, coord);
+  }
+
+  return result;
+}
+
 static naRef f_waypoint_navaid(naContext c, naRef me, int argc, naRef* args)
 {
   flightgear::Waypt* w = wayptGhost(me);
@@ -2076,6 +2344,7 @@ static struct { const char* name; naCFunction func; } funcs[] = {
   { "findNavaidsByID", f_findNavaidsByIdent },
   { "findFixesByID", f_findFixesByIdent },
   { "flightplan", f_route },
+  { "registerFlightPlanDelegate", f_registerFPDelegate },
   { "createWP", f_createWP },
   { "createWPFrom", f_createWPFrom },
   { "airwaysRoute", f_airwaySearch },
@@ -2094,6 +2363,7 @@ naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
     hashset(c, gcSave, "airportProto", airportPrototype);
   
     hashset(c, airportPrototype, "runway", naNewFunc(c, naNewCCode(c, f_airport_runway)));
+    hashset(c, airportPrototype, "taxiway", naNewFunc(c, naNewCCode(c, f_airport_taxiway)));
     hashset(c, airportPrototype, "tower", naNewFunc(c, naNewCCode(c, f_airport_tower)));
     hashset(c, airportPrototype, "comms", naNewFunc(c, naNewCCode(c, f_airport_comms)));
     hashset(c, airportPrototype, "sids", naNewFunc(c, naNewCCode(c, f_airport_sids)));
@@ -2103,6 +2373,7 @@ naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
     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, "tostring", naNewFunc(c, naNewCCode(c, f_airport_toString)));
   
     flightplanPrototype = naNewHash(c);
     hashset(c, gcSave, "flightplanProto", flightplanPrototype);
@@ -2119,7 +2390,8 @@ naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
     hashset(c, flightplanPrototype, "cleanPlan", naNewFunc(c, naNewCCode(c, f_flightplan_clearPlan))); 
     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)));
+    
     waypointPrototype = naNewHash(c);
     hashset(c, gcSave, "wayptProto", waypointPrototype);
     
@@ -2136,6 +2408,7 @@ naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
     hashset(c, gcSave, "fpLegProto", 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)));
   
     for(int i=0; funcs[i].name; i++) {
       hashset(c, globals, funcs[i].name,