src/Scripting/NasalPositioned.cxx

   1 // NasalPositioned.cxx -- expose FGPositioned classes to Nasal
   2 //
   3 // Written by James Turner, started 2012.
   4 //
   5 // Copyright (C) 2012 James Turner
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #endif
  24
  25 #include <string.h>
  26
  27 #include "NasalPositioned.hxx"
  28
  29 #include <boost/foreach.hpp>
  30 #include <boost/algorithm/string/case_conv.hpp>
  31 #include <boost/tuple/tuple.hpp> // for boost::tie
  32
  33 #include <simgear/sg_inlines.h>
  34 #include <simgear/scene/material/mat.hxx>
  35 #include <simgear/magvar/magvar.hxx>
  36 #include <simgear/timing/sg_time.hxx>
  37 #include <simgear/bucket/newbucket.hxx>
  38
  39 #include <Airports/runways.hxx>
  40 #include <Airports/airport.hxx>
  41 #include <Airports/dynamics.hxx>
  42 #include <Airports/parking.hxx>
  43 #include <Scripting/NasalSys.hxx>
  44 #include <Navaids/navlist.hxx>
  45 #include <Navaids/procedure.hxx>
  46 #include <Main/globals.hxx>
  47 #include <Main/fg_props.hxx>
  48 #include <Scenery/scenery.hxx>
  49 #include <ATC/CommStation.hxx>
  50 #include <Navaids/FlightPlan.hxx>
  51 #include <Navaids/waypoint.hxx>
  52 #include <Navaids/fix.hxx>
  53 #include <Autopilot/route_mgr.hxx>
  54 #include <Navaids/routePath.hxx>
  55 #include <Navaids/procedure.hxx>
  56 #include <Navaids/airways.hxx>
  57 #include <Navaids/NavDataCache.hxx>
  58
  59 using namespace flightgear;
  60
  61 static void positionedGhostDestroy(void* g);
  62 static void wayptGhostDestroy(void* g);
  63 static void legGhostDestroy(void* g);
  64 static void routeBaseGhostDestroy(void* g);
  65
  66 naGhostType PositionedGhostType = { positionedGhostDestroy, "positioned" };
  67
  68 static const char* airportGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  69 naGhostType AirportGhostType = { positionedGhostDestroy, "airport", airportGhostGetMember, 0 };
  70
  71 static const char* navaidGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  72 naGhostType NavaidGhostType = { positionedGhostDestroy, "navaid", navaidGhostGetMember, 0 };
  73
  74 static const char* runwayGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  75 naGhostType RunwayGhostType = { positionedGhostDestroy, "runway", runwayGhostGetMember, 0 };
  76 naGhostType HelipadGhostType = { positionedGhostDestroy, "helipad", runwayGhostGetMember, 0 };
  77 naGhostType TaxiwayGhostType = { positionedGhostDestroy, "taxiway", runwayGhostGetMember, 0 };
  78
  79 static const char* fixGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  80 naGhostType FixGhostType = { positionedGhostDestroy, "fix", fixGhostGetMember, 0 };
  81
  82 static const char* wayptGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  83 static void waypointGhostSetMember(naContext c, void* g, naRef field, naRef value);
  84
  85 naGhostType WayptGhostType = { wayptGhostDestroy,
  86   "waypoint",
  87   wayptGhostGetMember,
  88   waypointGhostSetMember};
  89
  90 static const char* legGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  91 static void legGhostSetMember(naContext c, void* g, naRef field, naRef value);
  92
  93 naGhostType FPLegGhostType = { legGhostDestroy,
  94   "flightplan-leg",
  95   legGhostGetMember,
  96   legGhostSetMember};
  97
  98 static const char* flightplanGhostGetMember(naContext c, void* g, naRef field, naRef* out);
  99 static void flightplanGhostSetMember(naContext c, void* g, naRef field, naRef value);
 100
 101 naGhostType FlightPlanGhostType = { routeBaseGhostDestroy,
 102   "flightplan",
 103   flightplanGhostGetMember,
 104   flightplanGhostSetMember
 105 };
 106
 107 static const char* procedureGhostGetMember(naContext c, void* g, naRef field, naRef* out);
 108 naGhostType ProcedureGhostType = { routeBaseGhostDestroy,
 109   "procedure",
 110   procedureGhostGetMember,
 111   0};
 112
 113 static void hashset(naContext c, naRef hash, const char* key, naRef val)
 114 {
 115   naRef s = naNewString(c);
 116   naStr_fromdata(s, (char*)key, strlen(key));
 117   naHash_set(hash, s, val);
 118 }
 119
 120 static naRef stringToNasal(naContext c, const std::string& s)
 121 {
 122     return naStr_fromdata(naNewString(c),
 123                    const_cast<char *>(s.c_str()),
 124                    s.length());
 125 }
 126
 127 static WayptFlag wayptFlagFromString(const char* s)
 128 {
 129   if (!strcmp(s, "sid")) return WPT_DEPARTURE;
 130   if (!strcmp(s, "star")) return WPT_ARRIVAL;
 131   if (!strcmp(s, "approach")) return WPT_APPROACH;
 132   if (!strcmp(s, "missed")) return WPT_MISS;
 133   if (!strcmp(s, "pseudo")) return WPT_PSEUDO;
 134
 135   return (WayptFlag) 0;
 136 }
 137
 138 static naRef wayptFlagToNasal(naContext c, unsigned int flags)
 139 {
 140   if (flags & WPT_PSEUDO) return stringToNasal(c, "pseudo");
 141   if (flags & WPT_DEPARTURE) return stringToNasal(c, "sid");
 142   if (flags & WPT_ARRIVAL) return stringToNasal(c, "star");
 143   if (flags & WPT_MISS) return stringToNasal(c, "missed");
 144   if (flags & WPT_APPROACH) return stringToNasal(c, "approach");
 145   return naNil();
 146 }
 147
 148 static FGPositioned* positionedGhost(naRef r)
 149 {
 150     if ((naGhost_type(r) == &AirportGhostType) ||
 151         (naGhost_type(r) == &NavaidGhostType) ||
 152         (naGhost_type(r) == &RunwayGhostType) ||
 153         (naGhost_type(r) == &FixGhostType))
 154     {
 155         return (FGPositioned*) naGhost_ptr(r);
 156     }
 157
 158     return 0;
 159 }
 160
 161 static FGAirport* airportGhost(naRef r)
 162 {
 163   if (naGhost_type(r) == &AirportGhostType)
 164     return (FGAirport*) naGhost_ptr(r);
 165   return 0;
 166 }
 167
 168 static FGNavRecord* navaidGhost(naRef r)
 169 {
 170   if (naGhost_type(r) == &NavaidGhostType)
 171     return (FGNavRecord*) naGhost_ptr(r);
 172   return 0;
 173 }
 174
 175 static FGRunway* runwayGhost(naRef r)
 176 {
 177   if (naGhost_type(r) == &RunwayGhostType)
 178     return (FGRunway*) naGhost_ptr(r);
 179   return 0;
 180 }
 181
 182 static FGTaxiway* taxiwayGhost(naRef r)
 183 {
 184   if (naGhost_type(r) == &TaxiwayGhostType)
 185     return (FGTaxiway*) naGhost_ptr(r);
 186   return 0;
 187 }
 188
 189 static FGFix* fixGhost(naRef r)
 190 {
 191   if (naGhost_type(r) == &FixGhostType)
 192     return (FGFix*) naGhost_ptr(r);
 193   return 0;
 194 }
 195
 196
 197 static void positionedGhostDestroy(void* g)
 198 {
 199     FGPositioned* pos = (FGPositioned*)g;
 200     if (!FGPositioned::put(pos)) // unref
 201         delete pos;
 202 }
 203
 204 static Waypt* wayptGhost(naRef r)
 205 {
 206   if (naGhost_type(r) == &WayptGhostType)
 207     return (Waypt*) naGhost_ptr(r);
 208
 209   if (naGhost_type(r) == &FPLegGhostType) {
 210     FlightPlan::Leg* leg = (FlightPlan::Leg*) naGhost_ptr(r);
 211     return leg->waypoint();
 212   }
 213
 214   return 0;
 215 }
 216
 217 static void wayptGhostDestroy(void* g)
 218 {
 219   Waypt* wpt = (Waypt*)g;
 220   if (!Waypt::put(wpt)) // unref
 221     delete wpt;
 222 }
 223
 224 static void legGhostDestroy(void* g)
 225 {
 226   // nothing for now
 227 }
 228
 229
 230 static FlightPlan::Leg* fpLegGhost(naRef r)
 231 {
 232   if (naGhost_type(r) == &FPLegGhostType)
 233     return (FlightPlan::Leg*) naGhost_ptr(r);
 234   return 0;
 235 }
 236
 237 static Procedure* procedureGhost(naRef r)
 238 {
 239   if (naGhost_type(r) == &ProcedureGhostType)
 240     return (Procedure*) naGhost_ptr(r);
 241   return 0;
 242 }
 243
 244 static FlightPlan* flightplanGhost(naRef r)
 245 {
 246   if (naGhost_type(r) == &FlightPlanGhostType)
 247     return (FlightPlan*) naGhost_ptr(r);
 248   return 0;
 249 }
 250
 251 static void routeBaseGhostDestroy(void* g)
 252 {
 253   // nothing for now
 254 }
 255
 256 static naRef airportPrototype;
 257 static naRef flightplanPrototype;
 258 static naRef waypointPrototype;
 259 static naRef geoCoordClass;
 260 static naRef fpLegPrototype;
 261 static naRef procedurePrototype;
 262
 263 naRef ghostForAirport(naContext c, const FGAirport* apt)
 264 {
 265   if (!apt) {
 266     return naNil();
 267   }
 268
 269   FGPositioned::get(apt); // take a ref
 270   return naNewGhost2(c, &AirportGhostType, (void*) apt);
 271 }
 272
 273 naRef ghostForNavaid(naContext c, const FGNavRecord* n)
 274 {
 275   if (!n) {
 276     return naNil();
 277   }
 278
 279   FGPositioned::get(n); // take a ref
 280   return naNewGhost2(c, &NavaidGhostType, (void*) n);
 281 }
 282
 283 naRef ghostForRunway(naContext c, const FGRunway* r)
 284 {
 285   if (!r) {
 286     return naNil();
 287   }
 288
 289   FGPositioned::get(r); // take a ref
 290   return naNewGhost2(c, &RunwayGhostType, (void*) r);
 291 }
 292
 293 naRef ghostForHelipad(naContext c, const FGHelipad* r)
 294 {
 295   if (!r) {
 296     return naNil();
 297   }
 298
 299   FGPositioned::get(r); // take a ref
 300   return naNewGhost2(c, &HelipadGhostType, (void*) r);
 301 }
 302
 303 naRef ghostForTaxiway(naContext c, const FGTaxiway* r)
 304 {
 305   if (!r) {
 306     return naNil();
 307   }
 308
 309   FGPositioned::get(r); // take a ref
 310   return naNewGhost2(c, &TaxiwayGhostType, (void*) r);
 311 }
 312
 313 naRef ghostForFix(naContext c, const FGFix* r)
 314 {
 315   if (!r) {
 316     return naNil();
 317   }
 318
 319   FGPositioned::get(r); // take a ref
 320   return naNewGhost2(c, &FixGhostType, (void*) r);
 321 }
 322
 323
 324 naRef ghostForWaypt(naContext c, const Waypt* wpt)
 325 {
 326   if (!wpt) {
 327     return naNil();
 328   }
 329
 330   Waypt::get(wpt); // take a ref
 331   return naNewGhost2(c, &WayptGhostType, (void*) wpt);
 332 }
 333
 334 naRef ghostForLeg(naContext c, const FlightPlan::Leg* leg)
 335 {
 336   if (!leg) {
 337     return naNil();
 338   }
 339
 340   return naNewGhost2(c, &FPLegGhostType, (void*) leg);
 341 }
 342
 343 naRef ghostForFlightPlan(naContext c, const FlightPlan* fp)
 344 {
 345   if (!fp) {
 346     return naNil();
 347   }
 348
 349   return naNewGhost2(c, &FlightPlanGhostType, (void*) fp);
 350 }
 351
 352 naRef ghostForProcedure(naContext c, const Procedure* proc)
 353 {
 354   if (!proc) {
 355     return naNil();
 356   }
 357
 358   return naNewGhost2(c, &ProcedureGhostType, (void*) proc);
 359 }
 360
 361 static const char* airportGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 362 {
 363   const char* fieldName = naStr_data(field);
 364   FGAirport* apt = (FGAirport*) g;
 365
 366   if (!strcmp(fieldName, "parents")) {
 367     *out = naNewVector(c);
 368     naVec_append(*out, airportPrototype);
 369   } else if (!strcmp(fieldName, "id")) *out = stringToNasal(c, apt->ident());
 370   else if (!strcmp(fieldName, "name")) *out = stringToNasal(c, apt->name());
 371   else if (!strcmp(fieldName, "lat")) *out = naNum(apt->getLatitude());
 372   else if (!strcmp(fieldName, "lon")) *out = naNum(apt->getLongitude());
 373   else if (!strcmp(fieldName, "elevation")) {
 374     *out = naNum(apt->getElevation() * SG_FEET_TO_METER);
 375   } else if (!strcmp(fieldName, "has_metar")) {
 376     *out = naNum(apt->getMetar());
 377   } else if (!strcmp(fieldName, "runways")) {
 378     *out = naNewHash(c);
 379     double minLengthFt = fgGetDouble("/sim/navdb/min-runway-length-ft");
 380     for(unsigned int r=0; r<apt->numRunways(); ++r) {
 381       FGRunway* rwy(apt->getRunwayByIndex(r));
 382       // ignore unusably short runways
 383       if (rwy->lengthFt() < minLengthFt) {
 384         continue;
 385       }
 386       naRef rwyid = stringToNasal(c, rwy->ident());
 387       naRef rwydata = ghostForRunway(c, rwy);
 388       naHash_set(*out, rwyid, rwydata);
 389     }
 390   } else if (!strcmp(fieldName, "helipads")) {
 391     *out = naNewHash(c);
 392
 393     for(unsigned int r=0; r<apt->numHelipads(); ++r) {
 394       FGHelipad* hp(apt->getHelipadByIndex(r));
 395
 396       naRef rwyid = stringToNasal(c, hp->ident());
 397       naRef rwydata = ghostForHelipad(c, hp);
 398       naHash_set(*out, rwyid, rwydata);
 399     }
 400
 401   } else if (!strcmp(fieldName, "taxiways")) {
 402     *out = naNewVector(c);
 403     for(unsigned int r=0; r<apt->numTaxiways(); ++r) {
 404       FGTaxiway* taxi(apt->getTaxiwayByIndex(r));
 405       naRef taxidata = ghostForTaxiway(c, taxi);
 406       naVec_append(*out, taxidata);
 407     }
 408
 409   } else {
 410     return 0;
 411   }
 412
 413   return "";
 414 }
 415
 416 static const char* waypointCommonGetMember(naContext c, Waypt* wpt, const char* fieldName, naRef* out)
 417 {
 418   if (!strcmp(fieldName, "wp_name") || !strcmp(fieldName, "id")) *out = stringToNasal(c, wpt->ident());
 419   else if (!strcmp(fieldName, "wp_type")) *out = stringToNasal(c, wpt->type());
 420   else if (!strcmp(fieldName, "wp_role")) *out = wayptFlagToNasal(c, wpt->flags());
 421   else if (!strcmp(fieldName, "wp_lat") || !strcmp(fieldName, "lat")) *out = naNum(wpt->position().getLatitudeDeg());
 422   else if (!strcmp(fieldName, "wp_lon") || !strcmp(fieldName, "lon")) *out = naNum(wpt->position().getLongitudeDeg());
 423   else if (!strcmp(fieldName, "wp_parent_name")) {
 424     Procedure* proc = dynamic_cast<Procedure*>(wpt->owner());
 425     *out = proc ? stringToNasal(c, proc->ident()) : naNil();
 426   } else if (!strcmp(fieldName, "wp_parent")) {
 427     Procedure* proc = dynamic_cast<Procedure*>(wpt->owner());
 428     *out = ghostForProcedure(c, proc);
 429   } else if (!strcmp(fieldName, "fly_type")) {
 430     if (wpt->type() == "hold") {
 431       *out = stringToNasal(c, "Hold");
 432     } else {
 433       *out = stringToNasal(c, wpt->flag(WPT_OVERFLIGHT) ? "flyOver" : "flyBy");
 434     }
 435   } else {
 436     return NULL; // member not found
 437   }
 438
 439   return "";
 440 }
 441
 442 static void waypointCommonSetMember(naContext c, Waypt* wpt, const char* fieldName, naRef value)
 443 {
 444   if (!strcmp(fieldName, "wp_role")) {
 445     if (!naIsString(value)) naRuntimeError(c, "wp_role must be a string");
 446     if (wpt->owner() != NULL) naRuntimeError(c, "cannot override wp_role on waypoint with parent");
 447     WayptFlag f = wayptFlagFromString(naStr_data(value));
 448     if (f == 0) {
 449       naRuntimeError(c, "unrecognized wp_role value %s", naStr_data(value));
 450     }
 451
 452     wpt->setFlag(f, true);
 453   }
 454 }
 455
 456 static const char* wayptGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 457 {
 458   const char* fieldName = naStr_data(field);
 459   Waypt* wpt = (flightgear::Waypt*) g;
 460   return waypointCommonGetMember(c, wpt, fieldName, out);
 461 }
 462
 463 static RouteRestriction routeRestrictionFromString(const char* s)
 464 {
 465   std::string u(s);
 466   boost::to_lower(u);
 467   if (u == "computed") return RESTRICT_COMPUTED;
 468   if (u == "at") return RESTRICT_AT;
 469   if (u == "mach") return SPEED_RESTRICT_MACH;
 470   if (u == "computed-mach") return SPEED_COMPUTED_MACH;
 471   if (u == "delete") return RESTRICT_DELETE;
 472   return RESTRICT_NONE;
 473 };
 474
 475 naRef routeRestrictionToNasal(naContext c, RouteRestriction rr)
 476 {
 477   switch (rr) {
 478     case RESTRICT_NONE: return naNil();
 479     case RESTRICT_AT: return stringToNasal(c, "at");
 480     case RESTRICT_ABOVE: return stringToNasal(c, "above");
 481     case RESTRICT_BELOW: return stringToNasal(c, "below");
 482     case SPEED_RESTRICT_MACH: return stringToNasal(c, "mach");
 483     case RESTRICT_COMPUTED: return stringToNasal(c, "computed");
 484     case SPEED_COMPUTED_MACH: return stringToNasal(c, "computed-mach");
 485     case RESTRICT_DELETE: return stringToNasal(c, "delete");
 486   }
 487
 488   return naNil();
 489 }
 490
 491 static const char* legGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 492 {
 493   const char* fieldName = naStr_data(field);
 494   FlightPlan::Leg* leg = (FlightPlan::Leg*) g;
 495   Waypt* wpt = leg->waypoint();
 496
 497   if (!strcmp(fieldName, "parents")) {
 498     *out = naNewVector(c);
 499     naVec_append(*out, fpLegPrototype);
 500     naVec_append(*out, waypointPrototype);
 501   } else if (!strcmp(fieldName, "index")) {
 502     *out = naNum(leg->index());
 503   } else if (!strcmp(fieldName, "alt_cstr")) {
 504     *out = naNum(leg->altitudeFt());
 505   } else if (!strcmp(fieldName, "alt_cstr_type")) {
 506     *out = routeRestrictionToNasal(c, leg->altitudeRestriction());
 507   } else if (!strcmp(fieldName, "speed_cstr")) {
 508     double s = isMachRestrict(leg->speedRestriction()) ? leg->speedMach() : leg->speedKts();
 509     *out = naNum(s);
 510   } else if (!strcmp(fieldName, "speed_cstr_type")) {
 511     *out = routeRestrictionToNasal(c, leg->speedRestriction());
 512   } else if (!strcmp(fieldName, "leg_distance")) {
 513     *out = naNum(leg->distanceNm());
 514   } else if (!strcmp(fieldName, "leg_bearing")) {
 515     *out = naNum(leg->courseDeg());
 516   } else if (!strcmp(fieldName, "distance_along_route")) {
 517     *out = naNum(leg->distanceAlongRoute());
 518   } else { // check for fields defined on the underlying waypoint
 519     return waypointCommonGetMember(c, wpt, fieldName, out);
 520   }
 521
 522   return ""; // success
 523 }
 524
 525 static void waypointGhostSetMember(naContext c, void* g, naRef field, naRef value)
 526 {
 527   const char* fieldName = naStr_data(field);
 528   Waypt* wpt = (Waypt*) g;
 529   waypointCommonSetMember(c, wpt, fieldName, value);
 530 }
 531
 532 static void legGhostSetMember(naContext c, void* g, naRef field, naRef value)
 533 {
 534   const char* fieldName = naStr_data(field);
 535   FlightPlan::Leg* leg = (FlightPlan::Leg*) g;
 536
 537   waypointCommonSetMember(c, leg->waypoint(), fieldName, value);
 538 }
 539
 540 static const char* flightplanGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 541 {
 542   const char* fieldName = naStr_data(field);
 543   FlightPlan* fp = (FlightPlan*) g;
 544
 545   if (!strcmp(fieldName, "parents")) {
 546     *out = naNewVector(c);
 547     naVec_append(*out, flightplanPrototype);
 548   } else if (!strcmp(fieldName, "id")) *out = stringToNasal(c, fp->ident());
 549   else if (!strcmp(fieldName, "departure")) *out = ghostForAirport(c, fp->departureAirport());
 550   else if (!strcmp(fieldName, "destination")) *out = ghostForAirport(c, fp->destinationAirport());
 551   else if (!strcmp(fieldName, "departure_runway")) *out = ghostForRunway(c, fp->departureRunway());
 552   else if (!strcmp(fieldName, "destination_runway")) *out = ghostForRunway(c, fp->destinationRunway());
 553   else if (!strcmp(fieldName, "sid")) *out = ghostForProcedure(c, fp->sid());
 554   else if (!strcmp(fieldName, "sid_trans")) *out = ghostForProcedure(c, fp->sidTransition());
 555   else if (!strcmp(fieldName, "star")) *out = ghostForProcedure(c, fp->star());
 556   else if (!strcmp(fieldName, "star_trans")) *out = ghostForProcedure(c, fp->starTransition());
 557   else if (!strcmp(fieldName, "approach")) *out = ghostForProcedure(c, fp->approach());
 558   else if (!strcmp(fieldName, "current")) *out = naNum(fp->currentIndex());
 559   else {
 560     return 0;
 561   }
 562
 563   return "";
 564 }
 565
 566 static void flightplanGhostSetMember(naContext c, void* g, naRef field, naRef value)
 567 {
 568   const char* fieldName = naStr_data(field);
 569   FlightPlan* fp = (FlightPlan*) g;
 570
 571   if (!strcmp(fieldName, "id")) {
 572     if (!naIsString(value)) naRuntimeError(c, "flightplan.id must be a string");
 573     fp->setIdent(naStr_data(value));
 574   } else if (!strcmp(fieldName, "current")) {
 575     int index = value.num;
 576     if ((index < 0) || (index >= fp->numLegs())) {
 577       return;
 578     }
 579     fp->setCurrentIndex(index);
 580   } else if (!strcmp(fieldName, "departure")) {
 581     FGAirport* apt = airportGhost(value);
 582     if (apt) {
 583       fp->setDeparture(apt);
 584       return;
 585     }
 586
 587     FGRunway* rwy = runwayGhost(value);
 588     if (rwy){
 589       fp->setDeparture(rwy);
 590       return;
 591     }
 592
 593     if (naIsNil(value)) {
 594       fp->setDeparture(static_cast<FGAirport*>(NULL));
 595       return;
 596     }
 597
 598     naRuntimeError(c, "bad argument type setting departure");
 599   } else if (!strcmp(fieldName, "destination")) {
 600     FGAirport* apt = airportGhost(value);
 601     if (apt) {
 602       fp->setDestination(apt);
 603       return;
 604     }
 605
 606     FGRunway* rwy = runwayGhost(value);
 607     if (rwy){
 608       fp->setDestination(rwy);
 609       return;
 610     }
 611
 612     naRuntimeError(c, "bad argument type setting destination");
 613   } else if (!strcmp(fieldName, "departure_runway")) {
 614     FGRunway* rwy = runwayGhost(value);
 615     if (rwy){
 616       fp->setDeparture(rwy);
 617       return;
 618     }
 619
 620     naRuntimeError(c, "bad argument type setting departure runway");
 621   } else if (!strcmp(fieldName, "destination_runway")) {
 622     FGRunway* rwy = runwayGhost(value);
 623     if (rwy){
 624       fp->setDestination(rwy);
 625       return;
 626     }
 627
 628     naRuntimeError(c, "bad argument type setting destination runway");
 629   } else if (!strcmp(fieldName, "sid")) {
 630     Procedure* proc = procedureGhost(value);
 631     if (proc && (proc->type() == PROCEDURE_SID)) {
 632       fp->setSID((flightgear::SID*) proc);
 633       return;
 634     }
 635     // allow a SID transition to be set, implicitly include the SID itself
 636     if (proc && (proc->type() == PROCEDURE_TRANSITION)) {
 637       fp->setSID((Transition*) proc);
 638       return;
 639     }
 640
 641     if (naIsString(value)) {
 642       FGAirport* apt = fp->departureAirport();
 643       fp->setSID(apt->findSIDWithIdent(naStr_data(value)));
 644       return;
 645     }
 646
 647     naRuntimeError(c, "bad argument type setting SID");
 648   } else if (!strcmp(fieldName, "star")) {
 649     Procedure* proc = procedureGhost(value);
 650     if (proc && (proc->type() == PROCEDURE_STAR)) {
 651       fp->setSTAR((STAR*) proc);
 652       return;
 653     }
 654
 655     if (proc && (proc->type() == PROCEDURE_TRANSITION)) {
 656       fp->setSTAR((Transition*) proc);
 657       return;
 658     }
 659
 660     if (naIsString(value)) {
 661       FGAirport* apt = fp->destinationAirport();
 662       fp->setSTAR(apt->findSTARWithIdent(naStr_data(value)));
 663       return;
 664     }
 665
 666     naRuntimeError(c, "bad argument type setting STAR");
 667   } else if (!strcmp(fieldName, "approach")) {
 668     Procedure* proc = procedureGhost(value);
 669     if (proc && Approach::isApproach(proc->type())) {
 670       fp->setApproach((Approach*) proc);
 671       return;
 672     }
 673
 674     if (naIsString(value)) {
 675       FGAirport* apt = fp->destinationAirport();
 676       fp->setApproach(apt->findApproachWithIdent(naStr_data(value)));
 677       return;
 678     }
 679
 680     naRuntimeError(c, "bad argument type setting approach");
 681   }
 682 }
 683
 684
 685 static naRef procedureTpType(naContext c, ProcedureType ty)
 686 {
 687   switch (ty) {
 688     case PROCEDURE_SID: return stringToNasal(c, "sid");
 689     case PROCEDURE_STAR: return stringToNasal(c, "star");
 690     case PROCEDURE_APPROACH_VOR:
 691     case PROCEDURE_APPROACH_ILS:
 692     case PROCEDURE_APPROACH_RNAV:
 693     case PROCEDURE_APPROACH_NDB:
 694       return stringToNasal(c, "IAP");
 695     default:
 696       return naNil();
 697   }
 698 }
 699
 700 static naRef procedureRadioType(naContext c, ProcedureType ty)
 701 {
 702   switch (ty) {
 703     case PROCEDURE_APPROACH_VOR: return stringToNasal(c, "VOR");
 704     case PROCEDURE_APPROACH_ILS: return stringToNasal(c, "ILS");
 705     case PROCEDURE_APPROACH_RNAV: return stringToNasal(c, "RNAV");
 706     case PROCEDURE_APPROACH_NDB: return stringToNasal(c, "NDB");
 707     default:
 708       return naNil();
 709   }
 710 }
 711
 712 static const char* procedureGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 713 {
 714   const char* fieldName = naStr_data(field);
 715   Procedure* proc = (Procedure*) g;
 716
 717   if (!strcmp(fieldName, "parents")) {
 718     *out = naNewVector(c);
 719     naVec_append(*out, procedurePrototype);
 720   } else if (!strcmp(fieldName, "id")) *out = stringToNasal(c, proc->ident());
 721   else if (!strcmp(fieldName, "airport")) *out = ghostForAirport(c, proc->airport());
 722   else if (!strcmp(fieldName, "tp_type")) *out = procedureTpType(c, proc->type());
 723   else if (!strcmp(fieldName, "radio")) *out = procedureRadioType(c, proc->type());
 724   else if (!strcmp(fieldName, "runways")) {
 725     *out = naNewVector(c);
 726     BOOST_FOREACH(FGRunwayRef rwy, proc->runways()) {
 727       naVec_append(*out, stringToNasal(c, rwy->ident()));
 728     }
 729   } else if (!strcmp(fieldName, "transitions")) {
 730     if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
 731       *out = naNil();
 732       return "";
 733     }
 734
 735     ArrivalDeparture* ad = static_cast<ArrivalDeparture*>(proc);
 736     *out = naNewVector(c);
 737     BOOST_FOREACH(std::string id, ad->transitionIdents()) {
 738       naVec_append(*out, stringToNasal(c, id));
 739     }
 740   } else {
 741     return 0;
 742   }
 743
 744   return "";
 745 }
 746
 747 static const char* runwayGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 748 {
 749   const char* fieldName = naStr_data(field);
 750   FGRunwayBase* base = (FGRunwayBase*) g;
 751
 752   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, base->ident());
 753   else if (!strcmp(fieldName, "lat")) *out = naNum(base->latitude());
 754   else if (!strcmp(fieldName, "lon")) *out = naNum(base->longitude());
 755   else if (!strcmp(fieldName, "heading")) *out = naNum(base->headingDeg());
 756   else if (!strcmp(fieldName, "length")) *out = naNum(base->lengthM());
 757   else if (!strcmp(fieldName, "width")) *out = naNum(base->widthM());
 758   else if (!strcmp(fieldName, "surface")) *out = naNum(base->surface());
 759   else if (base->type() == FGRunwayBase::RUNWAY) {
 760     FGRunway* rwy = (FGRunway*) g;
 761     if (!strcmp(fieldName, "threshold")) *out = naNum(rwy->displacedThresholdM());
 762     else if (!strcmp(fieldName, "stopway")) *out = naNum(rwy->stopwayM());
 763     else if (!strcmp(fieldName, "reciprocal")) {
 764       *out = ghostForRunway(c, rwy->reciprocalRunway());
 765     } else if (!strcmp(fieldName, "ils_frequency_mhz")) {
 766       *out = rwy->ILS() ? naNum(rwy->ILS()->get_freq() / 100.0) : naNil();
 767     } else if (!strcmp(fieldName, "ils")) {
 768       *out = ghostForNavaid(c, rwy->ILS());
 769     } else {
 770       return 0;
 771     }
 772   } else {
 773     return 0;
 774   }
 775
 776   return "";
 777 }
 778
 779 static const char* navaidGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 780 {
 781   const char* fieldName = naStr_data(field);
 782   FGNavRecord* nav = (FGNavRecord*) g;
 783
 784   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, nav->ident());
 785   else if (!strcmp(fieldName, "name")) *out = stringToNasal(c, nav->name());
 786   else if (!strcmp(fieldName, "lat")) *out = naNum(nav->get_lat());
 787   else if (!strcmp(fieldName, "lon")) *out = naNum(nav->get_lon());
 788   else if (!strcmp(fieldName, "elevation")) {
 789     *out = naNum(nav->get_elev_ft() * SG_FEET_TO_METER);
 790   } else if (!strcmp(fieldName, "type")) {
 791     *out = stringToNasal(c, nav->nameForType(nav->type()));
 792   } else if (!strcmp(fieldName, "frequency")) {
 793     *out = naNum(nav->get_freq());
 794   } else if (!strcmp(fieldName, "range_nm")) {
 795     *out = naNum(nav->get_range());
 796   } else if (!strcmp(fieldName, "course")) {
 797     if ((nav->type() == FGPositioned::ILS) || (nav->type() == FGPositioned::LOC)) {
 798       double radial = nav->get_multiuse();
 799       SG_NORMALIZE_RANGE(radial, 0.0, 360.0);
 800       *out = naNum(radial);
 801     } else {
 802       *out = naNil();
 803     }
 804   } else {
 805     return 0;
 806   }
 807
 808   return "";
 809 }
 810
 811 static const char* fixGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 812 {
 813   const char* fieldName = naStr_data(field);
 814   FGFix* fix = (FGFix*) g;
 815
 816   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, fix->ident());
 817   else if (!strcmp(fieldName, "lat")) *out = naNum(fix->get_lat());
 818   else if (!strcmp(fieldName, "lon")) *out = naNum(fix->get_lon());
 819   else {
 820     return 0;
 821   }
 822
 823   return "";
 824 }
 825
 826 static bool hashIsCoord(naRef h)
 827 {
 828   naRef parents = naHash_cget(h, (char*) "parents");
 829   if (!naIsVector(parents)) {
 830     return false;
 831   }
 832
 833   return naEqual(naVec_get(parents, 0), geoCoordClass) != 0;
 834 }
 835
 836 bool geodFromHash(naRef ref, SGGeod& result)
 837 {
 838   if (!naIsHash(ref)) {
 839     return false;
 840   }
 841
 842
 843 // check for manual latitude / longitude names
 844   naRef lat = naHash_cget(ref, (char*) "lat");
 845   naRef lon = naHash_cget(ref, (char*) "lon");
 846   if (naIsNum(lat) && naIsNum(lon)) {
 847     result = SGGeod::fromDeg(naNumValue(lon).num, naNumValue(lat).num);
 848     return true;
 849   }
 850
 851   if (hashIsCoord(ref)) {
 852     naRef lat = naHash_cget(ref, (char*) "_lat");
 853     naRef lon = naHash_cget(ref, (char*) "_lon");
 854     if (naIsNum(lat) && naIsNum(lon)) {
 855       result = SGGeod::fromRad(naNumValue(lon).num, naNumValue(lat).num);
 856       return true;
 857     }
 858   }
 859
 860 // check for any synonyms?
 861     // latitude + longitude?
 862
 863   return false;
 864 }
 865
 866 static int geodFromArgs(naRef* args, int offset, int argc, SGGeod& result)
 867 {
 868   if (offset >= argc) {
 869     return 0;
 870   }
 871
 872   if (naIsGhost(args[offset])) {
 873     naGhostType* gt = naGhost_type(args[offset]);
 874     if (gt == &AirportGhostType) {
 875       result = airportGhost(args[offset])->geod();
 876       return 1;
 877     }
 878
 879     if (gt == &NavaidGhostType) {
 880       result = navaidGhost(args[offset])->geod();
 881       return 1;
 882     }
 883
 884     if (gt == &RunwayGhostType) {
 885       result = runwayGhost(args[offset])->geod();
 886       return 1;
 887     }
 888
 889     if (gt == &TaxiwayGhostType) {
 890       result = taxiwayGhost(args[offset])->geod();
 891       return 1;
 892     }
 893
 894     if (gt == &FixGhostType) {
 895       result = fixGhost(args[offset])->geod();
 896       return 1;
 897     }
 898
 899     if (gt == &WayptGhostType) {
 900       result = wayptGhost(args[offset])->position();
 901       return 1;
 902     }
 903   }
 904
 905   if (geodFromHash(args[offset], result)) {
 906     return 1;
 907   }
 908
 909   if (((argc - offset) >= 2) && naIsNum(args[offset]) && naIsNum(args[offset + 1])) {
 910     double lat = naNumValue(args[0]).num,
 911     lon = naNumValue(args[1]).num;
 912     result = SGGeod::fromDeg(lon, lat);
 913     return 2;
 914   }
 915
 916   return 0;
 917 }
 918
 919 // Convert a cartesian point to a geodetic lat/lon/altitude.
 920 static naRef f_carttogeod(naContext c, naRef me, int argc, naRef* args)
 921 {
 922   double lat, lon, alt, xyz[3];
 923   if(argc != 3) naRuntimeError(c, "carttogeod() expects 3 arguments");
 924   for(int i=0; i<3; i++)
 925     xyz[i] = naNumValue(args[i]).num;
 926   sgCartToGeod(xyz, &lat, &lon, &alt);
 927   lat *= SG_RADIANS_TO_DEGREES;
 928   lon *= SG_RADIANS_TO_DEGREES;
 929   naRef vec = naNewVector(c);
 930   naVec_append(vec, naNum(lat));
 931   naVec_append(vec, naNum(lon));
 932   naVec_append(vec, naNum(alt));
 933   return vec;
 934 }
 935
 936 // Convert a geodetic lat/lon/altitude to a cartesian point.
 937 static naRef f_geodtocart(naContext c, naRef me, int argc, naRef* args)
 938 {
 939   if(argc != 3) naRuntimeError(c, "geodtocart() expects 3 arguments");
 940   double lat = naNumValue(args[0]).num * SG_DEGREES_TO_RADIANS;
 941   double lon = naNumValue(args[1]).num * SG_DEGREES_TO_RADIANS;
 942   double alt = naNumValue(args[2]).num;
 943   double xyz[3];
 944   sgGeodToCart(lat, lon, alt, xyz);
 945   naRef vec = naNewVector(c);
 946   naVec_append(vec, naNum(xyz[0]));
 947   naVec_append(vec, naNum(xyz[1]));
 948   naVec_append(vec, naNum(xyz[2]));
 949   return vec;
 950 }
 951
 952 // For given geodetic point return array with elevation, and a material data
 953 // hash, or nil if there's no information available (tile not loaded). If
 954 // information about the material isn't available, then nil is returned instead
 955 // of the hash.
 956 static naRef f_geodinfo(naContext c, naRef me, int argc, naRef* args)
 957 {
 958 #define HASHSET(s,l,n) naHash_set(matdata, naStr_fromdata(naNewString(c),s,l),n)
 959   if(argc < 2 || argc > 3)
 960     naRuntimeError(c, "geodinfo() expects 2 or 3 arguments: lat, lon [, maxalt]");
 961   double lat = naNumValue(args[0]).num;
 962   double lon = naNumValue(args[1]).num;
 963   double elev = argc == 3 ? naNumValue(args[2]).num : 10000;
 964   const simgear::BVHMaterial *material;
 965   SGGeod geod = SGGeod::fromDegM(lon, lat, elev);
 966   if(!globals->get_scenery()->get_elevation_m(geod, elev, &material))
 967     return naNil();
 968   const SGMaterial *mat = dynamic_cast<const SGMaterial *>(material);
 969   naRef vec = naNewVector(c);
 970   naVec_append(vec, naNum(elev));
 971   naRef matdata = naNil();
 972   if(mat) {
 973     matdata = naNewHash(c);
 974     naRef names = naNewVector(c);
 975     BOOST_FOREACH(const std::string& n, mat->get_names())
 976       naVec_append(names, stringToNasal(c, n));
 977
 978     HASHSET("names", 5, names);
 979     HASHSET("solid", 5, naNum(mat->get_solid()));
 980     HASHSET("friction_factor", 15, naNum(mat->get_friction_factor()));
 981     HASHSET("rolling_friction", 16, naNum(mat->get_rolling_friction()));
 982     HASHSET("load_resistance", 15, naNum(mat->get_load_resistance()));
 983     HASHSET("bumpiness", 9, naNum(mat->get_bumpiness()));
 984     HASHSET("light_coverage", 14, naNum(mat->get_light_coverage()));
 985   }
 986   naVec_append(vec, matdata);
 987   return vec;
 988 #undef HASHSET
 989 }
 990
 991
 992 // Returns data hash for particular or nearest airport of a <type>, or nil
 993 // on error.
 994 //
 995 // airportinfo(<id>);                   e.g. "KSFO"
 996 // airportinfo(<type>);                 type := ("airport"|"seaport"|"heliport")
 997 // airportinfo()                        same as  airportinfo("airport")
 998 // airportinfo(<lat>, <lon> [, <type>]);
 999 static naRef f_airportinfo(naContext c, naRef me, int argc, naRef* args)
1000 {
1001   SGGeod pos = globals->get_aircraft_position();
1002   FGAirport* apt = NULL;
1003
1004   if(argc >= 2 && naIsNum(args[0]) && naIsNum(args[1])) {
1005     pos = SGGeod::fromDeg(args[1].num, args[0].num);
1006     args += 2;
1007     argc -= 2;
1008   }
1009
1010   double maxRange = 10000.0; // expose this? or pick a smaller value?
1011
1012   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1013
1014   if(argc == 0) {
1015     // fall through and use AIRPORT
1016   } else if(argc == 1 && naIsString(args[0])) {
1017     if (filter.fromTypeString(naStr_data(args[0]))) {
1018       // done!
1019     } else {
1020       // user provided an <id>, hopefully
1021       apt = FGAirport::findByIdent(naStr_data(args[0]));
1022       if (!apt) {
1023         // return nil here, but don't raise a runtime error; this is a
1024         // legitamate way to validate an ICAO code, for example in a
1025         // dialog box or similar.
1026         return naNil();
1027       }
1028     }
1029   } else {
1030     naRuntimeError(c, "airportinfo() with invalid function arguments");
1031     return naNil();
1032   }
1033
1034   if(!apt) {
1035     apt = FGAirport::findClosest(pos, maxRange, &filter);
1036     if(!apt) return naNil();
1037   }
1038
1039   return ghostForAirport(c, apt);
1040 }
1041
1042 static naRef f_findAirportsWithinRange(naContext c, naRef me, int argc, naRef* args)
1043 {
1044   int argOffset = 0;
1045   SGGeod pos = globals->get_aircraft_position();
1046   argOffset += geodFromArgs(args, 0, argc, pos);
1047
1048   if (!naIsNum(args[argOffset])) {
1049     naRuntimeError(c, "findAirportsWithinRange expected range (in nm) as arg %d", argOffset);
1050   }
1051
1052   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1053   double rangeNm = args[argOffset++].num;
1054   if (argOffset < argc) {
1055     filter.fromTypeString(naStr_data(args[argOffset++]));
1056   }
1057
1058   naRef r = naNewVector(c);
1059
1060   FGPositionedList apts = FGPositioned::findWithinRange(pos, rangeNm, &filter);
1061   FGPositioned::sortByRange(apts, pos);
1062
1063   BOOST_FOREACH(FGPositionedRef a, apts) {
1064     FGAirport* apt = (FGAirport*) a.get();
1065     naVec_append(r, ghostForAirport(c, apt));
1066   }
1067
1068   return r;
1069 }
1070
1071 static naRef f_findAirportsByICAO(naContext c, naRef me, int argc, naRef* args)
1072 {
1073   if (!naIsString(args[0])) {
1074     naRuntimeError(c, "findAirportsByICAO expects string as arg 0");
1075   }
1076
1077   int argOffset = 0;
1078   std::string prefix(naStr_data(args[argOffset++]));
1079   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1080   if (argOffset < argc) {
1081     filter.fromTypeString(naStr_data(args[argOffset++]));
1082   }
1083
1084   naRef r = naNewVector(c);
1085
1086   FGPositionedList apts = FGPositioned::findAllWithIdent(prefix, &filter, false);
1087
1088   BOOST_FOREACH(FGPositionedRef a, apts) {
1089     FGAirport* apt = (FGAirport*) a.get();
1090     naVec_append(r, ghostForAirport(c, apt));
1091   }
1092
1093   return r;
1094 }
1095
1096 static naRef f_airport_tower(naContext c, naRef me, int argc, naRef* args)
1097 {
1098     FGAirport* apt = airportGhost(me);
1099     if (!apt) {
1100       naRuntimeError(c, "airport.tower called on non-airport object");
1101     }
1102
1103     // build a hash for the tower position
1104     SGGeod towerLoc = apt->getTowerLocation();
1105     naRef tower = naNewHash(c);
1106     hashset(c, tower, "lat", naNum(towerLoc.getLatitudeDeg()));
1107     hashset(c, tower, "lon", naNum(towerLoc.getLongitudeDeg()));
1108     hashset(c, tower, "elevation", naNum(towerLoc.getElevationM()));
1109     return tower;
1110 }
1111
1112 static naRef f_airport_comms(naContext c, naRef me, int argc, naRef* args)
1113 {
1114     FGAirport* apt = airportGhost(me);
1115     if (!apt) {
1116       naRuntimeError(c, "airport.comms called on non-airport object");
1117     }
1118     naRef comms = naNewVector(c);
1119
1120 // if we have an explicit type, return a simple vector of frequencies
1121     if (argc > 0 && naIsScalar(args[0])) {
1122         std::string commName = naStr_data(args[0]);
1123         FGPositioned::Type commType = FGPositioned::typeFromName(commName);
1124
1125         BOOST_FOREACH(flightgear::CommStation* comm, apt->commStationsOfType(commType)) {
1126             naVec_append(comms, naNum(comm->freqMHz()));
1127         }
1128     } else {
1129 // otherwise return a vector of hashes, one for each comm station.
1130         BOOST_FOREACH(flightgear::CommStation* comm, apt->commStations()) {
1131             naRef commHash = naNewHash(c);
1132             hashset(c, commHash, "frequency", naNum(comm->freqMHz()));
1133             hashset(c, commHash, "ident", stringToNasal(c, comm->ident()));
1134             naVec_append(comms, commHash);
1135         }
1136     }
1137
1138     return comms;
1139 }
1140
1141 static naRef f_airport_runway(naContext c, naRef me, int argc, naRef* args)
1142 {
1143   FGAirport* apt = airportGhost(me);
1144   if (!apt) {
1145     naRuntimeError(c, "airport.runway called on non-airport object");
1146   }
1147
1148   if ((argc < 1) || !naIsString(args[0])) {
1149     naRuntimeError(c, "airport.runway expects a runway ident argument");
1150   }
1151
1152   std::string ident(naStr_data(args[0]));
1153   boost::to_upper(ident);
1154
1155   if (apt->hasRunwayWithIdent(ident)) {
1156     return ghostForRunway(c, apt->getRunwayByIdent(ident));
1157   } else if (apt->hasHelipadWithIdent(ident)) {
1158     return ghostForHelipad(c, apt->getHelipadByIdent(ident));
1159   }
1160   return naNil();
1161 }
1162
1163 static naRef f_airport_runwaysWithoutReciprocals(naContext c, naRef me, int argc, naRef* args)
1164 {
1165   FGAirport* apt = airportGhost(me);
1166   if (!apt) {
1167     naRuntimeError(c, "airport.runwaysWithoutReciprocals called on non-airport object");
1168   }
1169
1170   FGRunwayList rwylist(apt->getRunwaysWithoutReciprocals());
1171   naRef runways = naNewVector(c);
1172   for (unsigned int r=0; r<rwylist.size(); ++r) {
1173     FGRunway* rwy(rwylist[r]);
1174     naVec_append(runways, ghostForRunway(c, apt->getRunwayByIdent(rwy->ident())));
1175   }
1176   return runways;
1177 }
1178
1179 static naRef f_airport_sids(naContext c, naRef me, int argc, naRef* args)
1180 {
1181   FGAirport* apt = airportGhost(me);
1182   if (!apt) {
1183     naRuntimeError(c, "airport.sids called on non-airport object");
1184   }
1185
1186   naRef sids = naNewVector(c);
1187
1188   FGRunway* rwy = NULL;
1189   if (argc > 0 && naIsString(args[0])) {
1190     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1191       return naNil();
1192     }
1193
1194     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1195   } else if (argc > 0) {
1196     rwy = runwayGhost(args[0]);
1197   }
1198
1199   if (rwy) {
1200     BOOST_FOREACH(flightgear::SID* sid, rwy->getSIDs()) {
1201       naRef procId = stringToNasal(c, sid->ident());
1202       naVec_append(sids, procId);
1203     }
1204   } else {
1205     for (unsigned int s=0; s<apt->numSIDs(); ++s) {
1206       flightgear::SID* sid = apt->getSIDByIndex(s);
1207       naRef procId = stringToNasal(c, sid->ident());
1208       naVec_append(sids, procId);
1209     }
1210   }
1211
1212   return sids;
1213 }
1214
1215 static naRef f_airport_stars(naContext c, naRef me, int argc, naRef* args)
1216 {
1217   FGAirport* apt = airportGhost(me);
1218   if (!apt) {
1219     naRuntimeError(c, "airport.stars called on non-airport object");
1220   }
1221
1222   naRef stars = naNewVector(c);
1223
1224   FGRunway* rwy = NULL;
1225   if (argc > 0 && naIsString(args[0])) {
1226     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1227       return naNil();
1228     }
1229
1230     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1231   } else if (argc > 0) {
1232     rwy = runwayGhost(args[0]);
1233   }
1234
1235   if (rwy) {
1236     BOOST_FOREACH(flightgear::STAR* s, rwy->getSTARs()) {
1237       naRef procId = stringToNasal(c, s->ident());
1238       naVec_append(stars, procId);
1239     }
1240   } else {
1241     for (unsigned int s=0; s<apt->numSTARs(); ++s) {
1242       flightgear::STAR* star = apt->getSTARByIndex(s);
1243       naRef procId = stringToNasal(c, star->ident());
1244       naVec_append(stars, procId);
1245     }
1246   }
1247
1248   return stars;
1249 }
1250
1251 static naRef f_airport_approaches(naContext c, naRef me, int argc, naRef* args)
1252 {
1253   FGAirport* apt = airportGhost(me);
1254   if (!apt) {
1255     naRuntimeError(c, "airport.getApproachList called on non-airport object");
1256   }
1257
1258   naRef approaches = naNewVector(c);
1259
1260   ProcedureType ty = PROCEDURE_INVALID;
1261   if ((argc > 1) && naIsString(args[1])) {
1262     std::string u(naStr_data(args[1]));
1263     boost::to_upper(u);
1264     if (u == "NDB") ty = PROCEDURE_APPROACH_NDB;
1265     if (u == "VOR") ty = PROCEDURE_APPROACH_VOR;
1266     if (u == "ILS") ty = PROCEDURE_APPROACH_ILS;
1267     if (u == "RNAV") ty = PROCEDURE_APPROACH_RNAV;
1268   }
1269
1270   FGRunway* rwy = NULL;
1271   if (argc > 0 && (rwy = runwayGhost(args[0]))) {
1272     // ok
1273   } else if (argc > 0 && naIsString(args[0])) {
1274     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1275       return naNil();
1276     }
1277
1278     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1279   }
1280
1281   if (rwy) {
1282     BOOST_FOREACH(Approach* s, rwy->getApproaches()) {
1283       if ((ty != PROCEDURE_INVALID) && (s->type() != ty)) {
1284         continue;
1285       }
1286
1287       naRef procId = stringToNasal(c, s->ident());
1288       naVec_append(approaches, procId);
1289     }
1290   } else {
1291     // no runway specified, report them all
1292     for (unsigned int s=0; s<apt->numApproaches(); ++s) {
1293       Approach* app = apt->getApproachByIndex(s);
1294       if ((ty != PROCEDURE_INVALID) && (app->type() != ty)) {
1295         continue;
1296       }
1297
1298       naRef procId = stringToNasal(c, app->ident());
1299       naVec_append(approaches, procId);
1300     }
1301   }
1302
1303   return approaches;
1304 }
1305
1306 static naRef f_airport_parking(naContext c, naRef me, int argc, naRef* args)
1307 {
1308   FGAirport* apt = airportGhost(me);
1309   if (!apt) {
1310     naRuntimeError(c, "airport.parking called on non-airport object");
1311   }
1312
1313   naRef r = naNewVector(c);
1314   std::string type;
1315   bool onlyAvailable = false;
1316
1317   if (argc > 0 && naIsString(args[0])) {
1318     type = naStr_data(args[0]);
1319   }
1320
1321   if ((argc > 1) && naIsNum(args[1])) {
1322     onlyAvailable = (args[1].num != 0.0);
1323   }
1324
1325   FGAirportDynamics* dynamics = apt->getDynamics();
1326   PositionedIDVec parkings = flightgear::NavDataCache::instance()->airportItemsOfType(apt->guid(),
1327                                                                                       FGPositioned::PARKING);
1328
1329   BOOST_FOREACH(PositionedID parking, parkings) {
1330     // filter out based on availability and type
1331     if (onlyAvailable && !dynamics->isParkingAvailable(parking)) {
1332       continue;
1333     }
1334
1335     FGParking* park = dynamics->getParking(parking);
1336     if (!type.empty() && (park->getType() != type)) {
1337       continue;
1338     }
1339
1340     const SGGeod& parkLoc = park->geod();
1341     naRef ph = naNewHash(c);
1342     hashset(c, ph, "name", stringToNasal(c, park->getName()));
1343     hashset(c, ph, "lat", naNum(parkLoc.getLatitudeDeg()));
1344     hashset(c, ph, "lon", naNum(parkLoc.getLongitudeDeg()));
1345     hashset(c, ph, "elevation", naNum(parkLoc.getElevationM()));
1346     naVec_append(r, ph);
1347   }
1348
1349   return r;
1350 }
1351
1352 static naRef f_airport_getSid(naContext c, naRef me, int argc, naRef* args)
1353 {
1354   FGAirport* apt = airportGhost(me);
1355   if (!apt) {
1356     naRuntimeError(c, "airport.getSid called on non-airport object");
1357   }
1358
1359   if ((argc != 1) || !naIsString(args[0])) {
1360     naRuntimeError(c, "airport.getSid passed invalid argument");
1361   }
1362
1363   std::string ident = naStr_data(args[0]);
1364   return ghostForProcedure(c, apt->findSIDWithIdent(ident));
1365 }
1366
1367 static naRef f_airport_getStar(naContext c, naRef me, int argc, naRef* args)
1368 {
1369   FGAirport* apt = airportGhost(me);
1370   if (!apt) {
1371     naRuntimeError(c, "airport.getStar called on non-airport object");
1372   }
1373
1374   if ((argc != 1) || !naIsString(args[0])) {
1375     naRuntimeError(c, "airport.getStar passed invalid argument");
1376   }
1377
1378   std::string ident = naStr_data(args[0]);
1379   return ghostForProcedure(c, apt->findSTARWithIdent(ident));
1380 }
1381
1382 static naRef f_airport_getApproach(naContext c, naRef me, int argc, naRef* args)
1383 {
1384   FGAirport* apt = airportGhost(me);
1385   if (!apt) {
1386     naRuntimeError(c, "airport.getIAP called on non-airport object");
1387   }
1388
1389   if ((argc != 1) || !naIsString(args[0])) {
1390     naRuntimeError(c, "airport.getIAP passed invalid argument");
1391   }
1392
1393   std::string ident = naStr_data(args[0]);
1394   return ghostForProcedure(c, apt->findApproachWithIdent(ident));
1395 }
1396
1397 static naRef f_airport_findBestRunway(naContext c, naRef me, int argc, naRef* args)
1398 {
1399     FGAirport* apt = airportGhost(me);
1400     if (!apt) {
1401         naRuntimeError(c, "findBestRunway called on non-airport object");
1402     }
1403
1404     SGGeod pos;
1405     if (!geodFromArgs(args, 0, argc, pos)) {
1406         naRuntimeError(c, "findBestRunway must be passed a position");
1407     }
1408
1409     return ghostForRunway(c,  apt->findBestRunwayForPos(pos));
1410 }
1411
1412 static naRef f_airport_toString(naContext c, naRef me, int argc, naRef* args)
1413 {
1414   FGAirport* apt = airportGhost(me);
1415   if (!apt) {
1416     naRuntimeError(c, "airport.tostring called on non-airport object");
1417   }
1418
1419   return stringToNasal(c, "an airport " + apt->ident());
1420 }
1421
1422 // Returns vector of data hash for navaid of a <type>, nil on error
1423 // navaids sorted by ascending distance
1424 // navinfo([<lat>,<lon>],[<type>],[<id>])
1425 // lat/lon (numeric): use latitude/longitude instead of ac position
1426 // type:              ("fix"|"vor"|"ndb"|"ils"|"dme"|"tacan"|"any")
1427 // id:                (partial) id of the fix
1428 // examples:
1429 // navinfo("vor")     returns all vors
1430 // navinfo("HAM")     return all navaids who's name start with "HAM"
1431 // navinfo("vor", "HAM") return all vor who's name start with "HAM"
1432 //navinfo(34,48,"vor","HAM") return all vor who's name start with "HAM"
1433 //                           sorted by distance relative to lat=34, lon=48
1434 static naRef f_navinfo(naContext c, naRef me, int argc, naRef* args)
1435 {
1436   SGGeod pos;
1437
1438   if(argc >= 2 && naIsNum(args[0]) && naIsNum(args[1])) {
1439     pos = SGGeod::fromDeg(args[1].num, args[0].num);
1440     args += 2;
1441     argc -= 2;
1442   } else {
1443     pos = globals->get_aircraft_position();
1444   }
1445
1446   FGPositioned::Type type = FGPositioned::INVALID;
1447   nav_list_type navlist;
1448   const char * id = "";
1449
1450   if(argc > 0 && naIsString(args[0])) {
1451     const char *s = naStr_data(args[0]);
1452     if(!strcmp(s, "any")) type = FGPositioned::INVALID;
1453     else if(!strcmp(s, "fix")) type = FGPositioned::FIX;
1454     else if(!strcmp(s, "vor")) type = FGPositioned::VOR;
1455     else if(!strcmp(s, "ndb")) type = FGPositioned::NDB;
1456     else if(!strcmp(s, "ils")) type = FGPositioned::ILS;
1457     else if(!strcmp(s, "dme")) type = FGPositioned::DME;
1458     else if(!strcmp(s, "tacan")) type = FGPositioned::TACAN;
1459     else id = s; // this is an id
1460     ++args;
1461     --argc;
1462   }
1463
1464   if(argc > 0 && naIsString(args[0])) {
1465     if( *id != 0 ) {
1466       naRuntimeError(c, "navinfo() called with navaid id");
1467       return naNil();
1468     }
1469     id = naStr_data(args[0]);
1470     ++args;
1471     --argc;
1472   }
1473
1474   if( argc > 0 ) {
1475     naRuntimeError(c, "navinfo() called with too many arguments");
1476     return naNil();
1477   }
1478
1479   FGNavList::TypeFilter filter(type);
1480   navlist = FGNavList::findByIdentAndFreq( pos, id, 0.0, &filter );
1481
1482   naRef reply = naNewVector(c);
1483   for( nav_list_type::const_iterator it = navlist.begin(); it != navlist.end(); ++it ) {
1484     naVec_append( reply, ghostForNavaid(c, *it) );
1485   }
1486   return reply;
1487 }
1488
1489 static naRef f_findNavaidsWithinRange(naContext c, naRef me, int argc, naRef* args)
1490 {
1491   int argOffset = 0;
1492   SGGeod pos = globals->get_aircraft_position();
1493   argOffset += geodFromArgs(args, 0, argc, pos);
1494
1495   if (!naIsNum(args[argOffset])) {
1496     naRuntimeError(c, "findNavaidsWithinRange expected range (in nm) as arg %d", argOffset);
1497   }
1498
1499   FGPositioned::Type type = FGPositioned::INVALID;
1500   double rangeNm = args[argOffset++].num;
1501   if (argOffset < argc) {
1502     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1503   }
1504
1505   naRef r = naNewVector(c);
1506   FGNavList::TypeFilter filter(type);
1507   FGPositionedList navs = FGPositioned::findWithinRange(pos, rangeNm, &filter);
1508   FGPositioned::sortByRange(navs, pos);
1509
1510   BOOST_FOREACH(FGPositionedRef a, navs) {
1511     FGNavRecord* nav = (FGNavRecord*) a.get();
1512     naVec_append(r, ghostForNavaid(c, nav));
1513   }
1514
1515   return r;
1516 }
1517
1518 static naRef f_findNavaidByFrequency(naContext c, naRef me, int argc, naRef* args)
1519 {
1520   int argOffset = 0;
1521   SGGeod pos = globals->get_aircraft_position();
1522   argOffset += geodFromArgs(args, 0, argc, pos);
1523
1524   if (!naIsNum(args[argOffset])) {
1525     naRuntimeError(c, "findNavaidByFrequency expectes frequency (in Mhz) as arg %d", argOffset);
1526   }
1527
1528   FGPositioned::Type type = FGPositioned::INVALID;
1529   double freqMhz = args[argOffset++].num;
1530   if (argOffset < argc) {
1531     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1532   }
1533
1534   FGNavList::TypeFilter filter(type);
1535   nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
1536   if (navs.empty()) {
1537     return naNil();
1538   }
1539
1540   return ghostForNavaid(c, navs.front().ptr());
1541 }
1542
1543 static naRef f_findNavaidsByFrequency(naContext c, naRef me, int argc, naRef* args)
1544 {
1545   int argOffset = 0;
1546   SGGeod pos = globals->get_aircraft_position();
1547   argOffset += geodFromArgs(args, 0, argc, pos);
1548
1549   if (!naIsNum(args[argOffset])) {
1550     naRuntimeError(c, "findNavaidsByFrequency expectes frequency (in Mhz) as arg %d", argOffset);
1551   }
1552
1553   FGPositioned::Type type = FGPositioned::INVALID;
1554   double freqMhz = args[argOffset++].num;
1555   if (argOffset < argc) {
1556     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1557   }
1558
1559   naRef r = naNewVector(c);
1560
1561   FGNavList::TypeFilter filter(type);
1562   nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
1563
1564   BOOST_FOREACH(nav_rec_ptr a, navs) {
1565     naVec_append(r, ghostForNavaid(c, a.ptr()));
1566   }
1567
1568   return r;
1569 }
1570
1571 static naRef f_findNavaidsByIdent(naContext c, naRef me, int argc, naRef* args)
1572 {
1573   int argOffset = 0;
1574   SGGeod pos = globals->get_aircraft_position();
1575   argOffset += geodFromArgs(args, 0, argc, pos);
1576
1577   if (!naIsString(args[argOffset])) {
1578     naRuntimeError(c, "findNavaidsByIdent expectes ident string as arg %d", argOffset);
1579   }
1580
1581   FGPositioned::Type type = FGPositioned::INVALID;
1582   std::string ident = naStr_data(args[argOffset++]);
1583   if (argOffset < argc) {
1584     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1585   }
1586
1587   FGNavList::TypeFilter filter(type);
1588   naRef r = naNewVector(c);
1589   nav_list_type navs = FGNavList::findByIdentAndFreq(pos, ident, 0.0, &filter);
1590
1591   BOOST_FOREACH(nav_rec_ptr a, navs) {
1592     naVec_append(r, ghostForNavaid(c, a.ptr()));
1593   }
1594
1595   return r;
1596 }
1597
1598 static naRef f_findFixesByIdent(naContext c, naRef me, int argc, naRef* args)
1599 {
1600   int argOffset = 0;
1601   SGGeod pos = globals->get_aircraft_position();
1602   argOffset += geodFromArgs(args, 0, argc, pos);
1603
1604   if (!naIsString(args[argOffset])) {
1605     naRuntimeError(c, "findFixesByIdent expectes ident string as arg %d", argOffset);
1606   }
1607
1608   std::string ident(naStr_data(args[argOffset]));
1609   naRef r = naNewVector(c);
1610
1611   FGPositioned::TypeFilter filter(FGPositioned::FIX);
1612   FGPositionedList fixes = FGPositioned::findAllWithIdent(ident, &filter);
1613   FGPositioned::sortByRange(fixes, pos);
1614
1615   BOOST_FOREACH(FGPositionedRef f, fixes) {
1616     naVec_append(r, ghostForFix(c, (FGFix*) f.ptr()));
1617   }
1618
1619   return r;
1620 }
1621
1622 // Convert a cartesian point to a geodetic lat/lon/altitude.
1623 static naRef f_magvar(naContext c, naRef me, int argc, naRef* args)
1624 {
1625   SGGeod pos = globals->get_aircraft_position();
1626   if (argc == 0) {
1627     // fine, use aircraft position
1628   } else if (geodFromArgs(args, 0, argc, pos)) {
1629     // okay
1630   } else {
1631     naRuntimeError(c, "magvar() expects no arguments, a positioned hash or lat,lon pair");
1632   }
1633
1634   double jd = globals->get_time_params()->getJD();
1635   double magvarDeg = sgGetMagVar(pos, jd) * SG_RADIANS_TO_DEGREES;
1636   return naNum(magvarDeg);
1637 }
1638
1639 static naRef f_courseAndDistance(naContext c, naRef me, int argc, naRef* args)
1640 {
1641     SGGeod from = globals->get_aircraft_position(), to, p;
1642     int argOffset = geodFromArgs(args, 0, argc, p);
1643     if (geodFromArgs(args, argOffset, argc, to)) {
1644       from = p; // we parsed both FROM and TO args, so first was from
1645     } else {
1646       to = p; // only parsed one arg, so FROM is current
1647     }
1648
1649     if (argOffset == 0) {
1650         naRuntimeError(c, "invalid arguments to courseAndDistance");
1651     }
1652
1653     double course, course2, d;
1654     SGGeodesy::inverse(from, to, course, course2, d);
1655
1656     naRef result = naNewVector(c);
1657     naVec_append(result, naNum(course));
1658     naVec_append(result, naNum(d * SG_METER_TO_NM));
1659     return result;
1660 }
1661
1662 static naRef f_greatCircleMove(naContext c, naRef me, int argc, naRef* args)
1663 {
1664   SGGeod from = globals->get_aircraft_position(), to;
1665   int argOffset = 0;
1666
1667   // complication - don't inerpret two doubles (as the only args)
1668   // as a lat,lon pair - only do so if we have at least three args.
1669   if (argc > 2) {
1670     argOffset = geodFromArgs(args, 0, argc, from);
1671   }
1672
1673   if ((argOffset + 1) >= argc) {
1674     naRuntimeError(c, "isufficent arguments to greatCircleMove");
1675   }
1676
1677   if (!naIsNum(args[argOffset]) || !naIsNum(args[argOffset+1])) {
1678     naRuntimeError(c, "invalid arguments %d and %d to greatCircleMove",
1679                    argOffset, argOffset + 1);
1680   }
1681
1682   double course = args[argOffset].num, course2;
1683   double distanceNm = args[argOffset + 1].num;
1684   SGGeodesy::direct(from, course, distanceNm * SG_NM_TO_METER, to, course2);
1685
1686   // return geo.Coord
1687   naRef coord = naNewHash(c);
1688   hashset(c, coord, "lat", naNum(to.getLatitudeDeg()));
1689   hashset(c, coord, "lon", naNum(to.getLongitudeDeg()));
1690   return coord;
1691 }
1692
1693 static naRef f_tilePath(naContext c, naRef me, int argc, naRef* args)
1694 {
1695     SGGeod pos = globals->get_aircraft_position();
1696     geodFromArgs(args, 0, argc, pos);
1697     SGBucket b(pos);
1698     return stringToNasal(c, b.gen_base_path());
1699 }
1700
1701 static naRef f_tileIndex(naContext c, naRef me, int argc, naRef* args)
1702 {
1703   SGGeod pos = globals->get_aircraft_position();
1704   geodFromArgs(args, 0, argc, pos);
1705   SGBucket b(pos);
1706   return naNum(b.gen_index());
1707 }
1708
1709 static naRef f_route(naContext c, naRef me, int argc, naRef* args)
1710 {
1711   if (argc == 0) {
1712     FGRouteMgr* rm = static_cast<FGRouteMgr*>(globals->get_subsystem("route-manager"));
1713     return ghostForFlightPlan(c, rm->flightPlan());
1714   }
1715
1716   if ((argc > 0) && naIsString(args[0])) {
1717     flightgear::FlightPlan* fp = new flightgear::FlightPlan;
1718     SGPath path(naStr_data(args[0]));
1719     if (!path.exists()) {
1720       naRuntimeError(c, "flightplan, no file at path %s", path.c_str());
1721     }
1722
1723     if (!fp->load(path)) {
1724       SG_LOG(SG_NASAL, SG_WARN, "failed to load flight-plan from " << path);
1725       delete fp;
1726       return naNil();
1727     }
1728
1729     return ghostForFlightPlan(c, fp);
1730   }
1731
1732   naRuntimeError(c, "bad arguments to flightplan()");
1733   return naNil();
1734 }
1735
1736 class NasalFPDelegate : public FlightPlan::Delegate
1737 {
1738 public:
1739   NasalFPDelegate(FlightPlan* fp, FGNasalSys* sys, naRef ins) :
1740     _nasal(sys),
1741     _plan(fp),
1742     _instance(ins)
1743   {
1744     _gcSaveKey = _nasal->gcSave(ins);
1745   }
1746
1747   virtual ~NasalFPDelegate()
1748   {
1749     _nasal->gcRelease(_gcSaveKey);
1750   }
1751
1752   virtual void departureChanged()
1753   {
1754     callDelegateMethod("departureChanged");
1755   }
1756
1757   virtual void arrivalChanged()
1758   {
1759     callDelegateMethod("arrivalChanged");
1760   }
1761
1762   virtual void waypointsChanged()
1763   {
1764     callDelegateMethod("waypointsChanged");
1765   }
1766
1767   virtual void currentWaypointChanged()
1768   {
1769     callDelegateMethod("currentWaypointChanged");
1770   }
1771
1772   virtual void cleared()
1773   {
1774     callDelegateMethod("cleared");
1775   }
1776
1777   virtual void endOfFlightPlan()
1778   {
1779     callDelegateMethod("endOfFlightPlan");
1780   }
1781 private:
1782
1783   void callDelegateMethod(const char* method)
1784   {
1785     naRef f;
1786     if (naMember_cget(_nasal->context(), _instance, method, &f) == 0) {
1787       return; // no method on the delegate
1788     }
1789
1790     naRef arg[1];
1791     arg[0] = ghostForFlightPlan(_nasal->context(), _plan);
1792     _nasal->callMethod(f, _instance, 1, arg, naNil());
1793   }
1794
1795   FGNasalSys* _nasal;
1796   FlightPlan* _plan;
1797   naRef _instance;
1798   int _gcSaveKey;
1799 };
1800
1801 class NasalFPDelegateFactory : public FlightPlan::DelegateFactory
1802 {
1803 public:
1804   NasalFPDelegateFactory(naRef code)
1805   {
1806     _nasal = (FGNasalSys*) globals->get_subsystem("nasal");
1807     _func = code;
1808     _gcSaveKey = _nasal->gcSave(_func);
1809   }
1810
1811   ~NasalFPDelegateFactory()
1812   {
1813     _nasal->gcRelease(_gcSaveKey);
1814   }
1815
1816   virtual FlightPlan::Delegate* createFlightPlanDelegate(FlightPlan* fp)
1817   {
1818     naRef args[1];
1819     args[0] = ghostForFlightPlan(_nasal->context(), fp);
1820     naRef instance = _nasal->call(_func, 1, args, naNil());
1821     if (naIsNil(instance)) {
1822       return NULL;
1823     }
1824
1825     return new NasalFPDelegate(fp, _nasal, instance);
1826   }
1827 private:
1828   FGNasalSys* _nasal;
1829   naRef _func;
1830   int _gcSaveKey;
1831 };
1832
1833 static naRef f_registerFPDelegate(naContext c, naRef me, int argc, naRef* args)
1834 {
1835   if ((argc < 1) || !naIsFunc(args[0])) {
1836     naRuntimeError(c, "non-function argument to registerFlightPlanDelegate");
1837   }
1838
1839   NasalFPDelegateFactory* factory = new NasalFPDelegateFactory(args[0]);
1840   FlightPlan::registerDelegateFactory(factory);
1841
1842   return naNil();
1843 }
1844
1845 static WayptRef wayptFromArg(naRef arg)
1846 {
1847   WayptRef r = wayptGhost(arg);
1848   if (r.valid()) {
1849     return r;
1850   }
1851
1852   FGPositioned* pos = positionedGhost(arg);
1853   if (!pos) {
1854     // let's check if the arg is hash, coudl extra a geod and hence build
1855     // a simple waypoint
1856
1857     return WayptRef();
1858   }
1859
1860 // special-case for runways
1861   if (pos->type() == FGPositioned::RUNWAY) {
1862     return new RunwayWaypt((FGRunway*) pos, NULL);
1863   }
1864
1865   return new NavaidWaypoint(pos, NULL);
1866 }
1867
1868 static naRef convertWayptVecToNasal(naContext c, const WayptVec& wps)
1869 {
1870   naRef result = naNewVector(c);
1871   BOOST_FOREACH(WayptRef wpt, wps) {
1872     naVec_append(result, ghostForWaypt(c, wpt.get()));
1873   }
1874   return result;
1875 }
1876
1877 static naRef f_airwaySearch(naContext c, naRef me, int argc, naRef* args)
1878 {
1879   if (argc < 2) {
1880     naRuntimeError(c, "airwaysSearch needs at least two arguments");
1881   }
1882
1883   WayptRef start = wayptFromArg(args[0]),
1884     end = wayptFromArg(args[1]);
1885
1886   if (!start || !end) {
1887     SG_LOG(SG_NASAL, SG_WARN, "airwaysSearch: start or end points are invalid");
1888     return naNil();
1889   }
1890
1891   bool highLevel = true;
1892   if ((argc > 2) && naIsString(args[2])) {
1893     if (!strcmp(naStr_data(args[2]), "lowlevel")) {
1894       highLevel = false;
1895     }
1896   }
1897
1898   WayptVec route;
1899   if (highLevel) {
1900     Airway::highLevel()->route(start, end, route);
1901   } else {
1902     Airway::lowLevel()->route(start, end, route);
1903   }
1904
1905   return convertWayptVecToNasal(c, route);
1906 }
1907
1908 static naRef f_createWP(naContext c, naRef me, int argc, naRef* args)
1909 {
1910   SGGeod pos;
1911   int argOffset = geodFromArgs(args, 0, argc, pos);
1912
1913   if (((argc - argOffset) < 1) || !naIsString(args[argOffset])) {
1914     naRuntimeError(c, "createWP: no identifier supplied");
1915   }
1916
1917   std::string ident = naStr_data(args[argOffset++]);
1918   WayptRef wpt = new BasicWaypt(pos, ident, NULL);
1919
1920 // set waypt flags - approach, departure, pseudo, etc
1921   if (argc > argOffset) {
1922     WayptFlag f = wayptFlagFromString(naStr_data(args[argOffset++]));
1923     if (f == 0) {
1924       naRuntimeError(c, "createWP: bad waypoint role");
1925     }
1926
1927     wpt->setFlag(f);
1928   }
1929
1930   return ghostForWaypt(c, wpt);
1931 }
1932
1933 static naRef f_createWPFrom(naContext c, naRef me, int argc, naRef* args)
1934 {
1935   if (argc < 1) {
1936     naRuntimeError(c, "createWPFrom: need at least one argument");
1937   }
1938
1939   FGPositioned* positioned = positionedGhost(args[0]);
1940   if (!positioned) {
1941     naRuntimeError(c, "createWPFrom: couldn;t convert arg[0] to FGPositioned");
1942   }
1943
1944   WayptRef wpt;
1945   if (positioned->type() == FGPositioned::RUNWAY) {
1946     wpt = new RunwayWaypt((FGRunway*) positioned, NULL);
1947   } else {
1948     wpt = new NavaidWaypoint(positioned, NULL);
1949   }
1950
1951   // set waypt flags - approach, departure, pseudo, etc
1952   if (argc > 1) {
1953     WayptFlag f = wayptFlagFromString(naStr_data(args[1]));
1954     if (f == 0) {
1955       naRuntimeError(c, "createWPFrom: bad waypoint role");
1956     }
1957     wpt->setFlag(f);
1958   }
1959
1960   return ghostForWaypt(c, wpt);
1961 }
1962
1963 static naRef f_flightplan_getWP(naContext c, naRef me, int argc, naRef* args)
1964 {
1965   FlightPlan* fp = flightplanGhost(me);
1966   if (!fp) {
1967     naRuntimeError(c, "flightplan.getWP called on non-flightplan object");
1968   }
1969
1970   int index;
1971   if (argc == 0) {
1972     index = fp->currentIndex();
1973   } else {
1974     index = (int) naNumValue(args[0]).num;
1975   }
1976
1977   if ((index < 0) || (index >= fp->numLegs())) {
1978     return naNil();
1979   }
1980
1981   return ghostForLeg(c, fp->legAtIndex(index));
1982 }
1983
1984 static naRef f_flightplan_currentWP(naContext c, naRef me, int argc, naRef* args)
1985 {
1986   FlightPlan* fp = flightplanGhost(me);
1987   if (!fp) {
1988     naRuntimeError(c, "flightplan.currentWP called on non-flightplan object");
1989   }
1990   return ghostForLeg(c, fp->currentLeg());
1991 }
1992
1993 static naRef f_flightplan_nextWP(naContext c, naRef me, int argc, naRef* args)
1994 {
1995   FlightPlan* fp = flightplanGhost(me);
1996   if (!fp) {
1997     naRuntimeError(c, "flightplan.nextWP called on non-flightplan object");
1998   }
1999   return ghostForLeg(c, fp->nextLeg());
2000 }
2001
2002 static naRef f_flightplan_numWaypoints(naContext c, naRef me, int argc, naRef* args)
2003 {
2004   FlightPlan* fp = flightplanGhost(me);
2005   if (!fp) {
2006     naRuntimeError(c, "flightplan.numWaypoints called on non-flightplan object");
2007   }
2008   return naNum(fp->numLegs());
2009 }
2010
2011 static naRef f_flightplan_appendWP(naContext c, naRef me, int argc, naRef* args)
2012 {
2013   FlightPlan* fp = flightplanGhost(me);
2014   if (!fp) {
2015     naRuntimeError(c, "flightplan.appendWP called on non-flightplan object");
2016   }
2017
2018   WayptRef wp = wayptGhost(args[0]);
2019   int index = fp->numLegs();
2020   fp->insertWayptAtIndex(wp.get(), index);
2021   return naNum(index);
2022 }
2023
2024 static naRef f_flightplan_insertWP(naContext c, naRef me, int argc, naRef* args)
2025 {
2026   FlightPlan* fp = flightplanGhost(me);
2027   if (!fp) {
2028     naRuntimeError(c, "flightplan.insertWP called on non-flightplan object");
2029   }
2030
2031   WayptRef wp = wayptGhost(args[0]);
2032   int index = -1; // append
2033   if ((argc > 1) && naIsNum(args[1])) {
2034     index = (int) args[1].num;
2035   }
2036
2037   fp->insertWayptAtIndex(wp.get(), index);
2038   return naNil();
2039 }
2040
2041 static naRef f_flightplan_insertWPAfter(naContext c, naRef me, int argc, naRef* args)
2042 {
2043   FlightPlan* fp = flightplanGhost(me);
2044   if (!fp) {
2045     naRuntimeError(c, "flightplan.insertWPAfter called on non-flightplan object");
2046   }
2047
2048   WayptRef wp = wayptGhost(args[0]);
2049   int index = -1; // append
2050   if ((argc > 1) && naIsNum(args[1])) {
2051     index = (int) args[1].num;
2052   }
2053
2054   fp->insertWayptAtIndex(wp.get(), index + 1);
2055   return naNil();
2056 }
2057
2058 static naRef f_flightplan_insertWaypoints(naContext c, naRef me, int argc, naRef* args)
2059 {
2060   FlightPlan* fp = flightplanGhost(me);
2061   if (!fp) {
2062     naRuntimeError(c, "flightplan.insertWaypoints called on non-flightplan object");
2063   }
2064
2065   WayptVec wps;
2066   if (!naIsVector(args[0])) {
2067     naRuntimeError(c, "flightplan.insertWaypoints expects vector as first arg");
2068   }
2069
2070   int count = naVec_size(args[0]);
2071   for (int i=0; i<count; ++i) {
2072     Waypt* wp = wayptGhost(naVec_get(args[0], i));
2073     if (wp) {
2074       wps.push_back(wp);
2075     }
2076   }
2077
2078   int index = -1; // append
2079   if ((argc > 1) && naIsNum(args[1])) {
2080     index = (int) args[1].num;
2081   }
2082
2083   fp->insertWayptsAtIndex(wps, index);
2084   return naNil();
2085 }
2086
2087 static naRef f_flightplan_deleteWP(naContext c, naRef me, int argc, naRef* args)
2088 {
2089   FlightPlan* fp = flightplanGhost(me);
2090   if (!fp) {
2091     naRuntimeError(c, "flightplan.deleteWP called on non-flightplan object");
2092   }
2093
2094   if ((argc < 1) || !naIsNum(args[0])) {
2095     naRuntimeError(c, "bad argument to flightplan.deleteWP");
2096   }
2097
2098   int index = (int) args[0].num;
2099   fp->deleteIndex(index);
2100   return naNil();
2101 }
2102
2103 static naRef f_flightplan_clearPlan(naContext c, naRef me, int argc, naRef* args)
2104 {
2105   FlightPlan* fp = flightplanGhost(me);
2106   if (!fp) {
2107     naRuntimeError(c, "flightplan.clearPlan called on non-flightplan object");
2108   }
2109
2110   fp->clear();
2111   return naNil();
2112 }
2113
2114 static naRef f_flightplan_clearWPType(naContext c, naRef me, int argc, naRef* args)
2115 {
2116   FlightPlan* fp = flightplanGhost(me);
2117   if (!fp) {
2118     naRuntimeError(c, "flightplan.clearWPType called on non-flightplan object");
2119   }
2120
2121   if (argc < 1) {
2122     naRuntimeError(c, "insufficent args to flightplan.clearWPType");
2123   }
2124
2125   WayptFlag flag = wayptFlagFromString(naStr_data(args[0]));
2126   if (flag == 0) {
2127     naRuntimeError(c, "clearWPType: bad waypoint role");
2128   }
2129
2130   fp->clearWayptsWithFlag(flag);
2131   return naNil();
2132 }
2133
2134 static naRef f_flightplan_clone(naContext c, naRef me, int argc, naRef* args)
2135 {
2136   FlightPlan* fp = flightplanGhost(me);
2137   if (!fp) {
2138     naRuntimeError(c, "flightplan.clone called on non-flightplan object");
2139   }
2140
2141   return ghostForFlightPlan(c, fp->clone());
2142 }
2143
2144 static naRef f_flightplan_pathGeod(naContext c, naRef me, int argc, naRef* args)
2145 {
2146   FlightPlan* fp = flightplanGhost(me);
2147   if (!fp) {
2148     naRuntimeError(c, "flightplan.clone called on non-flightplan object");
2149   }
2150
2151   if ((argc < 1) || !naIsNum(args[0])) {
2152     naRuntimeError(c, "bad argument to flightplan.pathGeod");
2153   }
2154
2155   if ((argc > 1) && !naIsNum(args[1])) {
2156     naRuntimeError(c, "bad argument to flightplan.pathGeod");
2157   }
2158
2159   int index = (int) args[0].num;
2160   double offset = (argc > 1) ? args[1].num : 0.0;
2161   naRef result = naNewHash(c);
2162   SGGeod g = fp->pointAlongRoute(index, offset);
2163   hashset(c, result, "lat", naNum(g.getLatitudeDeg()));
2164   hashset(c, result, "lon", naNum(g.getLongitudeDeg()));
2165   return result;
2166 }
2167
2168 static naRef f_flightplan_finish(naContext c, naRef me, int argc, naRef* args)
2169 {
2170     FlightPlan* fp = flightplanGhost(me);
2171     if (!fp) {
2172         naRuntimeError(c, "flightplan.finish called on non-flightplan object");
2173     }
2174
2175     fp->finish();
2176     return naNil();
2177 }
2178
2179 static naRef f_leg_setSpeed(naContext c, naRef me, int argc, naRef* args)
2180 {
2181   FlightPlan::Leg* leg = fpLegGhost(me);
2182   if (!leg) {
2183     naRuntimeError(c, "leg.setSpeed called on non-flightplan-leg object");
2184   }
2185
2186   if (argc < 2) {
2187     naRuntimeError(c, "bad arguments to leg.setSpeed");
2188   }
2189
2190   RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
2191   leg->setSpeed(rr, args[0].num);
2192   return naNil();
2193 }
2194
2195 static naRef f_leg_setAltitude(naContext c, naRef me, int argc, naRef* args)
2196 {
2197   FlightPlan::Leg* leg = fpLegGhost(me);
2198   if (!leg) {
2199     naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
2200   }
2201
2202   if (argc < 2) {
2203     naRuntimeError(c, "bad arguments to leg.setAltitude");
2204   }
2205
2206   RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
2207   leg->setAltitude(rr, args[0].num);
2208   return naNil();
2209 }
2210
2211 static naRef f_leg_path(naContext c, naRef me, int argc, naRef* args)
2212 {
2213   FlightPlan::Leg* leg = fpLegGhost(me);
2214   if (!leg) {
2215     naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
2216   }
2217
2218   RoutePath path(leg->owner());
2219   SGGeodVec gv(path.pathForIndex(leg->index()));
2220
2221   naRef result = naNewVector(c);
2222   BOOST_FOREACH(SGGeod p, gv) {
2223     // construct a geo.Coord!
2224     naRef coord = naNewHash(c);
2225     hashset(c, coord, "lat", naNum(p.getLatitudeDeg()));
2226     hashset(c, coord, "lon", naNum(p.getLongitudeDeg()));
2227     naVec_append(result, coord);
2228   }
2229
2230   return result;
2231 }
2232
2233 static naRef f_leg_courseAndDistanceFrom(naContext c, naRef me, int argc, naRef* args)
2234 {
2235     FlightPlan::Leg* leg = fpLegGhost(me);
2236     if (!leg) {
2237         naRuntimeError(c, "leg.courseAndDistanceFrom called on non-flightplan-leg object");
2238     }
2239
2240     SGGeod pos;
2241     geodFromArgs(args, 0, argc, pos);
2242
2243     double courseDeg;
2244     double distanceM;
2245     boost::tie(courseDeg, distanceM) = leg->waypoint()->courseAndDistanceFrom(pos);
2246
2247     naRef result = naNewVector(c);
2248     naVec_append(result, naNum(courseDeg));
2249     naVec_append(result, naNum(distanceM * SG_METER_TO_NM));
2250     return result;
2251 }
2252
2253 static naRef f_waypoint_navaid(naContext c, naRef me, int argc, naRef* args)
2254 {
2255   flightgear::Waypt* w = wayptGhost(me);
2256   if (!w) {
2257     naRuntimeError(c, "waypoint.navaid called on non-waypoint object");
2258   }
2259
2260   FGPositioned* pos = w->source();
2261   if (!pos) {
2262     return naNil();
2263   }
2264
2265   switch (pos->type()) {
2266   case FGPositioned::VOR:
2267   case FGPositioned::NDB:
2268   case FGPositioned::ILS:
2269   case FGPositioned::LOC:
2270   case FGPositioned::GS:
2271   case FGPositioned::DME:
2272   case FGPositioned::TACAN: {
2273     FGNavRecord* nav = (FGNavRecord*) pos;
2274     return ghostForNavaid(c, nav);
2275   }
2276
2277   default:
2278     return naNil();
2279   }
2280 }
2281
2282 static naRef f_waypoint_airport(naContext c, naRef me, int argc, naRef* args)
2283 {
2284   flightgear::Waypt* w = wayptGhost(me);
2285   if (!w) {
2286     naRuntimeError(c, "waypoint.navaid called on non-waypoint object");
2287   }
2288
2289   FGPositioned* pos = w->source();
2290   if (!pos || FGAirport::isAirportType(pos)) {
2291     return naNil();
2292   }
2293
2294   return ghostForAirport(c, (FGAirport*) pos);
2295 }
2296
2297 static naRef f_waypoint_runway(naContext c, naRef me, int argc, naRef* args)
2298 {
2299   flightgear::Waypt* w = wayptGhost(me);
2300   if (!w) {
2301     naRuntimeError(c, "waypoint.navaid called on non-waypoint object");
2302   }
2303
2304   FGPositioned* pos = w->source();
2305   if (!pos || (pos->type() != FGPositioned::RUNWAY)) {
2306     return naNil();
2307   }
2308
2309   return ghostForRunway(c, (FGRunway*) pos);
2310 }
2311
2312 static naRef f_procedure_transition(naContext c, naRef me, int argc, naRef* args)
2313 {
2314   Procedure* proc = procedureGhost(me);
2315   if (!proc) {
2316     naRuntimeError(c, "procedure.transition called on non-procedure object");
2317   }
2318
2319   if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
2320     naRuntimeError(c, "procedure.transition called on non-SID or -STAR");
2321   }
2322
2323   ArrivalDeparture* ad = (ArrivalDeparture*) proc;
2324   Transition* trans = ad->findTransitionByName(naStr_data(args[0]));
2325
2326   return ghostForProcedure(c, trans);
2327 }
2328
2329 static naRef f_procedure_route(naContext c, naRef me, int argc, naRef* args)
2330 {
2331   Procedure* proc = procedureGhost(me);
2332   if (!proc) {
2333     naRuntimeError(c, "procedure.route called on non-procedure object");
2334   }
2335
2336 // wrapping up tow different routines here - approach routing from the IAF
2337 // to the associated runway, and SID/STAR routing via an enroute transition
2338 // and possibly a runway transition or not.
2339   if (Approach::isApproach(proc->type())) {
2340     WayptRef iaf;
2341     if (argc > 0) {
2342       iaf = wayptFromArg(args[0]);
2343     }
2344
2345     WayptVec r;
2346     Approach* app = (Approach*) proc;
2347     if (!app->route(iaf, r)) {
2348       SG_LOG(SG_NASAL, SG_WARN, "procedure.route failed for Approach somehow");
2349       return naNil();
2350     }
2351
2352     return convertWayptVecToNasal(c, r);
2353   } else if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
2354     naRuntimeError(c, "procedure.route called on unsuitable procedure type");
2355   }
2356
2357   int argOffset = 0;
2358   FGRunway* rwy = runwayGhost(args[0]);
2359   if (rwy) ++argOffset;
2360
2361   ArrivalDeparture* ad = (ArrivalDeparture*) proc;
2362   Transition* trans = NULL;
2363   if (argOffset < argc) {
2364     trans = (Transition*) procedureGhost(args[argOffset]);
2365   }
2366
2367   // note either runway or trans may be NULL - that's ok
2368   WayptVec r;
2369   if (!ad->route(rwy, trans, r)) {
2370     SG_LOG(SG_NASAL, SG_WARN, "prcoedure.route failed for ArrvialDeparture somehow");
2371     return naNil();
2372   }
2373
2374   return convertWayptVecToNasal(c, r);
2375 }
2376
2377
2378 // Table of extension functions.  Terminate with zeros.
2379 static struct { const char* name; naCFunction func; } funcs[] = {
2380   { "carttogeod", f_carttogeod },
2381   { "geodtocart", f_geodtocart },
2382   { "geodinfo", f_geodinfo },
2383   { "airportinfo", f_airportinfo },
2384   { "findAirportsWithinRange", f_findAirportsWithinRange },
2385   { "findAirportsByICAO", f_findAirportsByICAO },
2386   { "navinfo", f_navinfo },
2387   { "findNavaidsWithinRange", f_findNavaidsWithinRange },
2388   { "findNavaidByFrequency", f_findNavaidByFrequency },
2389   { "findNavaidsByFrequency", f_findNavaidsByFrequency },
2390   { "findNavaidsByID", f_findNavaidsByIdent },
2391   { "findFixesByID", f_findFixesByIdent },
2392   { "flightplan", f_route },
2393   { "registerFlightPlanDelegate", f_registerFPDelegate },
2394   { "createWP", f_createWP },
2395   { "createWPFrom", f_createWPFrom },
2396   { "airwaysRoute", f_airwaySearch },
2397   { "magvar", f_magvar },
2398   { "courseAndDistance", f_courseAndDistance },
2399   { "greatCircleMove", f_greatCircleMove },
2400   { "tileIndex", f_tileIndex },
2401   { "tilePath", f_tilePath },
2402   { 0, 0 }
2403 };
2404
2405
2406 naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
2407 {
2408     airportPrototype = naNewHash(c);
2409     hashset(c, gcSave, "airportProto", airportPrototype);
2410
2411     hashset(c, airportPrototype, "runway", naNewFunc(c, naNewCCode(c, f_airport_runway)));
2412     hashset(c, airportPrototype, "runwaysWithoutReciprocals", naNewFunc(c, naNewCCode(c, f_airport_runwaysWithoutReciprocals)));
2413     hashset(c, airportPrototype, "helipad", naNewFunc(c, naNewCCode(c, f_airport_runway)));
2414     hashset(c, airportPrototype, "tower", naNewFunc(c, naNewCCode(c, f_airport_tower)));
2415     hashset(c, airportPrototype, "comms", naNewFunc(c, naNewCCode(c, f_airport_comms)));
2416     hashset(c, airportPrototype, "sids", naNewFunc(c, naNewCCode(c, f_airport_sids)));
2417     hashset(c, airportPrototype, "stars", naNewFunc(c, naNewCCode(c, f_airport_stars)));
2418     hashset(c, airportPrototype, "getApproachList", naNewFunc(c, naNewCCode(c, f_airport_approaches)));
2419     hashset(c, airportPrototype, "parking", naNewFunc(c, naNewCCode(c, f_airport_parking)));
2420     hashset(c, airportPrototype, "getSid", naNewFunc(c, naNewCCode(c, f_airport_getSid)));
2421     hashset(c, airportPrototype, "getStar", naNewFunc(c, naNewCCode(c, f_airport_getStar)));
2422     hashset(c, airportPrototype, "getIAP", naNewFunc(c, naNewCCode(c, f_airport_getApproach)));
2423     hashset(c, airportPrototype, "findBestRunwayForPos", naNewFunc(c, naNewCCode(c, f_airport_findBestRunway)));
2424     hashset(c, airportPrototype, "tostring", naNewFunc(c, naNewCCode(c, f_airport_toString)));
2425
2426     flightplanPrototype = naNewHash(c);
2427     hashset(c, gcSave, "flightplanProto", flightplanPrototype);
2428
2429     hashset(c, flightplanPrototype, "getWP", naNewFunc(c, naNewCCode(c, f_flightplan_getWP)));
2430     hashset(c, flightplanPrototype, "currentWP", naNewFunc(c, naNewCCode(c, f_flightplan_currentWP)));
2431     hashset(c, flightplanPrototype, "nextWP", naNewFunc(c, naNewCCode(c, f_flightplan_nextWP)));
2432     hashset(c, flightplanPrototype, "getPlanSize", naNewFunc(c, naNewCCode(c, f_flightplan_numWaypoints)));
2433     hashset(c, flightplanPrototype, "appendWP", naNewFunc(c, naNewCCode(c, f_flightplan_appendWP)));
2434     hashset(c, flightplanPrototype, "insertWP", naNewFunc(c, naNewCCode(c, f_flightplan_insertWP)));
2435     hashset(c, flightplanPrototype, "deleteWP", naNewFunc(c, naNewCCode(c, f_flightplan_deleteWP)));
2436     hashset(c, flightplanPrototype, "insertWPAfter", naNewFunc(c, naNewCCode(c, f_flightplan_insertWPAfter)));
2437     hashset(c, flightplanPrototype, "insertWaypoints", naNewFunc(c, naNewCCode(c, f_flightplan_insertWaypoints)));
2438     hashset(c, flightplanPrototype, "cleanPlan", naNewFunc(c, naNewCCode(c, f_flightplan_clearPlan)));
2439     hashset(c, flightplanPrototype, "clearWPType", naNewFunc(c, naNewCCode(c, f_flightplan_clearWPType)));
2440     hashset(c, flightplanPrototype, "clone", naNewFunc(c, naNewCCode(c, f_flightplan_clone)));
2441     hashset(c, flightplanPrototype, "pathGeod", naNewFunc(c, naNewCCode(c, f_flightplan_pathGeod)));
2442     hashset(c, flightplanPrototype, "finish", naNewFunc(c, naNewCCode(c, f_flightplan_finish)));
2443
2444     waypointPrototype = naNewHash(c);
2445     hashset(c, gcSave, "wayptProto", waypointPrototype);
2446
2447     hashset(c, waypointPrototype, "navaid", naNewFunc(c, naNewCCode(c, f_waypoint_navaid)));
2448     hashset(c, waypointPrototype, "runway", naNewFunc(c, naNewCCode(c, f_waypoint_runway)));
2449     hashset(c, waypointPrototype, "airport", naNewFunc(c, naNewCCode(c, f_waypoint_airport)));
2450
2451     procedurePrototype = naNewHash(c);
2452     hashset(c, gcSave, "procedureProto", procedurePrototype);
2453     hashset(c, procedurePrototype, "transition", naNewFunc(c, naNewCCode(c, f_procedure_transition)));
2454     hashset(c, procedurePrototype, "route", naNewFunc(c, naNewCCode(c, f_procedure_route)));
2455
2456     fpLegPrototype = naNewHash(c);
2457     hashset(c, gcSave, "fpLegProto", fpLegPrototype);
2458     hashset(c, fpLegPrototype, "setSpeed", naNewFunc(c, naNewCCode(c, f_leg_setSpeed)));
2459     hashset(c, fpLegPrototype, "setAltitude", naNewFunc(c, naNewCCode(c, f_leg_setAltitude)));
2460     hashset(c, fpLegPrototype, "path", naNewFunc(c, naNewCCode(c, f_leg_path)));
2461     hashset(c, fpLegPrototype, "courseAndDistanceFrom", naNewFunc(c, naNewCCode(c, f_leg_courseAndDistanceFrom)));
2462
2463     for(int i=0; funcs[i].name; i++) {
2464       hashset(c, globals, funcs[i].name,
2465       naNewFunc(c, naNewCCode(c, funcs[i].func)));
2466     }
2467
2468   return naNil();
2469 }
2470
2471 void postinitNasalPositioned(naRef globals, naContext c)
2472 {
2473   naRef geoModule = naHash_cget(globals, (char*) "geo");
2474   if (naIsNil(geoModule)) {
2475     SG_LOG(SG_GENERAL, SG_WARN, "postinitNasalPositioned: geo.nas not loaded");
2476     return;
2477   }
2478
2479   geoCoordClass = naHash_cget(geoModule, (char*) "Coord");
2480 }
2481
2482