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")) *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")) *out = naNum(wpt->position().getLatitudeDeg());
 422   else if (!strcmp(fieldName, "wp_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   } else if (!strcmp(fieldName, "index")) {
 501     *out = naNum(leg->index());
 502   } else if (!strcmp(fieldName, "alt_cstr")) {
 503     *out = naNum(leg->altitudeFt());
 504   } else if (!strcmp(fieldName, "alt_cstr_type")) {
 505     *out = routeRestrictionToNasal(c, leg->altitudeRestriction());
 506   } else if (!strcmp(fieldName, "speed_cstr")) {
 507     double s = isMachRestrict(leg->speedRestriction()) ? leg->speedMach() : leg->speedKts();
 508     *out = naNum(s);
 509   } else if (!strcmp(fieldName, "speed_cstr_type")) {
 510     *out = routeRestrictionToNasal(c, leg->speedRestriction());
 511   } else if (!strcmp(fieldName, "leg_distance")) {
 512     *out = naNum(leg->distanceNm());
 513   } else if (!strcmp(fieldName, "leg_bearing")) {
 514     *out = naNum(leg->courseDeg());
 515   } else if (!strcmp(fieldName, "distance_along_route")) {
 516     *out = naNum(leg->distanceAlongRoute());
 517   } else { // check for fields defined on the underlying waypoint
 518     return waypointCommonGetMember(c, wpt, fieldName, out);
 519   }
 520
 521   return ""; // success
 522 }
 523
 524 static void waypointGhostSetMember(naContext c, void* g, naRef field, naRef value)
 525 {
 526   const char* fieldName = naStr_data(field);
 527   Waypt* wpt = (Waypt*) g;
 528   waypointCommonSetMember(c, wpt, fieldName, value);
 529 }
 530
 531 static void legGhostSetMember(naContext c, void* g, naRef field, naRef value)
 532 {
 533   const char* fieldName = naStr_data(field);
 534   FlightPlan::Leg* leg = (FlightPlan::Leg*) g;
 535
 536   waypointCommonSetMember(c, leg->waypoint(), fieldName, value);
 537 }
 538
 539 static const char* flightplanGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 540 {
 541   const char* fieldName = naStr_data(field);
 542   FlightPlan* fp = (FlightPlan*) g;
 543
 544   if (!strcmp(fieldName, "parents")) {
 545     *out = naNewVector(c);
 546     naVec_append(*out, flightplanPrototype);
 547   } else if (!strcmp(fieldName, "id")) *out = stringToNasal(c, fp->ident());
 548   else if (!strcmp(fieldName, "departure")) *out = ghostForAirport(c, fp->departureAirport());
 549   else if (!strcmp(fieldName, "destination")) *out = ghostForAirport(c, fp->destinationAirport());
 550   else if (!strcmp(fieldName, "departure_runway")) *out = ghostForRunway(c, fp->departureRunway());
 551   else if (!strcmp(fieldName, "destination_runway")) *out = ghostForRunway(c, fp->destinationRunway());
 552   else if (!strcmp(fieldName, "sid")) *out = ghostForProcedure(c, fp->sid());
 553   else if (!strcmp(fieldName, "sid_trans")) *out = ghostForProcedure(c, fp->sidTransition());
 554   else if (!strcmp(fieldName, "star")) *out = ghostForProcedure(c, fp->star());
 555   else if (!strcmp(fieldName, "star_trans")) *out = ghostForProcedure(c, fp->starTransition());
 556   else if (!strcmp(fieldName, "approach")) *out = ghostForProcedure(c, fp->approach());
 557   else if (!strcmp(fieldName, "current")) *out = naNum(fp->currentIndex());
 558   else {
 559     return 0;
 560   }
 561
 562   return "";
 563 }
 564
 565 static void flightplanGhostSetMember(naContext c, void* g, naRef field, naRef value)
 566 {
 567   const char* fieldName = naStr_data(field);
 568   FlightPlan* fp = (FlightPlan*) g;
 569
 570   if (!strcmp(fieldName, "id")) {
 571     if (!naIsString(value)) naRuntimeError(c, "flightplan.id must be a string");
 572     fp->setIdent(naStr_data(value));
 573   } else if (!strcmp(fieldName, "current")) {
 574     int index = value.num;
 575     if ((index < 0) || (index >= fp->numLegs())) {
 576       return;
 577     }
 578     fp->setCurrentIndex(index);
 579   } else if (!strcmp(fieldName, "departure")) {
 580     FGAirport* apt = airportGhost(value);
 581     if (apt) {
 582       fp->setDeparture(apt);
 583       return;
 584     }
 585
 586     FGRunway* rwy = runwayGhost(value);
 587     if (rwy){
 588       fp->setDeparture(rwy);
 589       return;
 590     }
 591
 592     naRuntimeError(c, "bad argument type setting departure");
 593   } else if (!strcmp(fieldName, "destination")) {
 594     FGAirport* apt = airportGhost(value);
 595     if (apt) {
 596       fp->setDestination(apt);
 597       return;
 598     }
 599
 600     FGRunway* rwy = runwayGhost(value);
 601     if (rwy){
 602       fp->setDestination(rwy);
 603       return;
 604     }
 605
 606     naRuntimeError(c, "bad argument type setting destination");
 607   } else if (!strcmp(fieldName, "departure_runway")) {
 608     FGRunway* rwy = runwayGhost(value);
 609     if (rwy){
 610       fp->setDeparture(rwy);
 611       return;
 612     }
 613
 614     naRuntimeError(c, "bad argument type setting departure");
 615   } else if (!strcmp(fieldName, "destination_runway")) {
 616     FGRunway* rwy = runwayGhost(value);
 617     if (rwy){
 618       fp->setDestination(rwy);
 619       return;
 620     }
 621
 622     naRuntimeError(c, "bad argument type setting departure");
 623   } else if (!strcmp(fieldName, "sid")) {
 624     Procedure* proc = procedureGhost(value);
 625     if (proc && (proc->type() == PROCEDURE_SID)) {
 626       fp->setSID((flightgear::SID*) proc);
 627       return;
 628     }
 629     // allow a SID transition to be set, implicitly include the SID itself
 630     if (proc && (proc->type() == PROCEDURE_TRANSITION)) {
 631       fp->setSID((Transition*) proc);
 632       return;
 633     }
 634
 635     if (naIsString(value)) {
 636       FGAirport* apt = fp->departureAirport();
 637       fp->setSID(apt->findSIDWithIdent(naStr_data(value)));
 638       return;
 639     }
 640
 641     naRuntimeError(c, "bad argument type setting SID");
 642   } else if (!strcmp(fieldName, "star")) {
 643     Procedure* proc = procedureGhost(value);
 644     if (proc && (proc->type() == PROCEDURE_STAR)) {
 645       fp->setSTAR((STAR*) proc);
 646       return;
 647     }
 648
 649     if (proc && (proc->type() == PROCEDURE_TRANSITION)) {
 650       fp->setSTAR((Transition*) proc);
 651       return;
 652     }
 653
 654     if (naIsString(value)) {
 655       FGAirport* apt = fp->destinationAirport();
 656       fp->setSTAR(apt->findSTARWithIdent(naStr_data(value)));
 657       return;
 658     }
 659
 660     naRuntimeError(c, "bad argument type setting STAR");
 661   } else if (!strcmp(fieldName, "approach")) {
 662     Procedure* proc = procedureGhost(value);
 663     if (proc && Approach::isApproach(proc->type())) {
 664       fp->setApproach((Approach*) proc);
 665       return;
 666     }
 667
 668     if (naIsString(value)) {
 669       FGAirport* apt = fp->destinationAirport();
 670       fp->setApproach(apt->findApproachWithIdent(naStr_data(value)));
 671       return;
 672     }
 673
 674     naRuntimeError(c, "bad argument type setting approach");
 675   }
 676 }
 677
 678
 679 static naRef procedureTpType(naContext c, ProcedureType ty)
 680 {
 681   switch (ty) {
 682     case PROCEDURE_SID: return stringToNasal(c, "sid");
 683     case PROCEDURE_STAR: return stringToNasal(c, "star");
 684     case PROCEDURE_APPROACH_VOR:
 685     case PROCEDURE_APPROACH_ILS:
 686     case PROCEDURE_APPROACH_RNAV:
 687     case PROCEDURE_APPROACH_NDB:
 688       return stringToNasal(c, "IAP");
 689     default:
 690       return naNil();
 691   }
 692 }
 693
 694 static naRef procedureRadioType(naContext c, ProcedureType ty)
 695 {
 696   switch (ty) {
 697     case PROCEDURE_APPROACH_VOR: return stringToNasal(c, "VOR");
 698     case PROCEDURE_APPROACH_ILS: return stringToNasal(c, "ILS");
 699     case PROCEDURE_APPROACH_RNAV: return stringToNasal(c, "RNAV");
 700     case PROCEDURE_APPROACH_NDB: return stringToNasal(c, "NDB");
 701     default:
 702       return naNil();
 703   }
 704 }
 705
 706 static const char* procedureGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 707 {
 708   const char* fieldName = naStr_data(field);
 709   Procedure* proc = (Procedure*) g;
 710
 711   if (!strcmp(fieldName, "parents")) {
 712     *out = naNewVector(c);
 713     naVec_append(*out, procedurePrototype);
 714   } else if (!strcmp(fieldName, "id")) *out = stringToNasal(c, proc->ident());
 715   else if (!strcmp(fieldName, "airport")) *out = ghostForAirport(c, proc->airport());
 716   else if (!strcmp(fieldName, "tp_type")) *out = procedureTpType(c, proc->type());
 717   else if (!strcmp(fieldName, "radio")) *out = procedureRadioType(c, proc->type());
 718   else if (!strcmp(fieldName, "runways")) {
 719     *out = naNewVector(c);
 720     BOOST_FOREACH(FGRunwayRef rwy, proc->runways()) {
 721       naVec_append(*out, stringToNasal(c, rwy->ident()));
 722     }
 723   } else if (!strcmp(fieldName, "transitions")) {
 724     if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
 725       *out = naNil();
 726       return "";
 727     }
 728
 729     ArrivalDeparture* ad = static_cast<ArrivalDeparture*>(proc);
 730     *out = naNewVector(c);
 731     BOOST_FOREACH(std::string id, ad->transitionIdents()) {
 732       naVec_append(*out, stringToNasal(c, id));
 733     }
 734   } else {
 735     return 0;
 736   }
 737
 738   return "";
 739 }
 740
 741 static const char* runwayGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 742 {
 743   const char* fieldName = naStr_data(field);
 744   FGRunwayBase* base = (FGRunwayBase*) g;
 745
 746   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, base->ident());
 747   else if (!strcmp(fieldName, "lat")) *out = naNum(base->latitude());
 748   else if (!strcmp(fieldName, "lon")) *out = naNum(base->longitude());
 749   else if (!strcmp(fieldName, "heading")) *out = naNum(base->headingDeg());
 750   else if (!strcmp(fieldName, "length")) *out = naNum(base->lengthM());
 751   else if (!strcmp(fieldName, "width")) *out = naNum(base->widthM());
 752   else if (!strcmp(fieldName, "surface")) *out = naNum(base->surface());
 753   else if (base->type() == FGRunwayBase::RUNWAY) {
 754     FGRunway* rwy = (FGRunway*) g;
 755     if (!strcmp(fieldName, "threshold")) *out = naNum(rwy->displacedThresholdM());
 756     else if (!strcmp(fieldName, "stopway")) *out = naNum(rwy->stopwayM());
 757     else if (!strcmp(fieldName, "reciprocal")) {
 758       *out = ghostForRunway(c, rwy->reciprocalRunway());
 759     } else if (!strcmp(fieldName, "ils_frequency_mhz")) {
 760       *out = rwy->ILS() ? naNum(rwy->ILS()->get_freq() / 100.0) : naNil();
 761     } else if (!strcmp(fieldName, "ils")) {
 762       *out = ghostForNavaid(c, rwy->ILS());
 763     } else {
 764       return 0;
 765     }
 766   } else {
 767     return 0;
 768   }
 769
 770   return "";
 771 }
 772
 773 static const char* navaidGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 774 {
 775   const char* fieldName = naStr_data(field);
 776   FGNavRecord* nav = (FGNavRecord*) g;
 777
 778   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, nav->ident());
 779   else if (!strcmp(fieldName, "name")) *out = stringToNasal(c, nav->name());
 780   else if (!strcmp(fieldName, "lat")) *out = naNum(nav->get_lat());
 781   else if (!strcmp(fieldName, "lon")) *out = naNum(nav->get_lon());
 782   else if (!strcmp(fieldName, "elevation")) {
 783     *out = naNum(nav->get_elev_ft() * SG_FEET_TO_METER);
 784   } else if (!strcmp(fieldName, "type")) {
 785     *out = stringToNasal(c, nav->nameForType(nav->type()));
 786   } else if (!strcmp(fieldName, "frequency")) {
 787     *out = naNum(nav->get_freq());
 788   } else if (!strcmp(fieldName, "range_nm")) {
 789     *out = naNum(nav->get_range());
 790   } else if (!strcmp(fieldName, "course")) {
 791     if ((nav->type() == FGPositioned::ILS) || (nav->type() == FGPositioned::LOC)) {
 792       double radial = nav->get_multiuse();
 793       SG_NORMALIZE_RANGE(radial, 0.0, 360.0);
 794       *out = naNum(radial);
 795     } else {
 796       *out = naNil();
 797     }
 798   } else {
 799     return 0;
 800   }
 801
 802   return "";
 803 }
 804
 805 static const char* fixGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 806 {
 807   const char* fieldName = naStr_data(field);
 808   FGFix* fix = (FGFix*) g;
 809
 810   if (!strcmp(fieldName, "id")) *out = stringToNasal(c, fix->ident());
 811   else if (!strcmp(fieldName, "lat")) *out = naNum(fix->get_lat());
 812   else if (!strcmp(fieldName, "lon")) *out = naNum(fix->get_lon());
 813   else {
 814     return 0;
 815   }
 816
 817   return "";
 818 }
 819
 820 static bool hashIsCoord(naRef h)
 821 {
 822   naRef parents = naHash_cget(h, (char*) "parents");
 823   if (!naIsVector(parents)) {
 824     return false;
 825   }
 826
 827   return naEqual(naVec_get(parents, 0), geoCoordClass) != 0;
 828 }
 829
 830 bool geodFromHash(naRef ref, SGGeod& result)
 831 {
 832   if (!naIsHash(ref)) {
 833     return false;
 834   }
 835
 836
 837 // check for manual latitude / longitude names
 838   naRef lat = naHash_cget(ref, (char*) "lat");
 839   naRef lon = naHash_cget(ref, (char*) "lon");
 840   if (naIsNum(lat) && naIsNum(lon)) {
 841     result = SGGeod::fromDeg(naNumValue(lon).num, naNumValue(lat).num);
 842     return true;
 843   }
 844
 845   if (hashIsCoord(ref)) {
 846     naRef lat = naHash_cget(ref, (char*) "_lat");
 847     naRef lon = naHash_cget(ref, (char*) "_lon");
 848     if (naIsNum(lat) && naIsNum(lon)) {
 849       result = SGGeod::fromRad(naNumValue(lon).num, naNumValue(lat).num);
 850       return true;
 851     }
 852   }
 853
 854 // check for any synonyms?
 855     // latitude + longitude?
 856
 857   return false;
 858 }
 859
 860 static int geodFromArgs(naRef* args, int offset, int argc, SGGeod& result)
 861 {
 862   if (offset >= argc) {
 863     return 0;
 864   }
 865
 866   if (naIsGhost(args[offset])) {
 867     naGhostType* gt = naGhost_type(args[offset]);
 868     if (gt == &AirportGhostType) {
 869       result = airportGhost(args[offset])->geod();
 870       return 1;
 871     }
 872
 873     if (gt == &NavaidGhostType) {
 874       result = navaidGhost(args[offset])->geod();
 875       return 1;
 876     }
 877
 878     if (gt == &RunwayGhostType) {
 879       result = runwayGhost(args[offset])->geod();
 880       return 1;
 881     }
 882
 883     if (gt == &TaxiwayGhostType) {
 884       result = taxiwayGhost(args[offset])->geod();
 885       return 1;
 886     }
 887
 888     if (gt == &FixGhostType) {
 889       result = fixGhost(args[offset])->geod();
 890       return 1;
 891     }
 892
 893     if (gt == &WayptGhostType) {
 894       result = wayptGhost(args[offset])->position();
 895       return 1;
 896     }
 897   }
 898
 899   if (geodFromHash(args[offset], result)) {
 900     return 1;
 901   }
 902
 903   if (((argc - offset) >= 2) && naIsNum(args[offset]) && naIsNum(args[offset + 1])) {
 904     double lat = naNumValue(args[0]).num,
 905     lon = naNumValue(args[1]).num;
 906     result = SGGeod::fromDeg(lon, lat);
 907     return 2;
 908   }
 909
 910   return 0;
 911 }
 912
 913 // Convert a cartesian point to a geodetic lat/lon/altitude.
 914 static naRef f_carttogeod(naContext c, naRef me, int argc, naRef* args)
 915 {
 916   double lat, lon, alt, xyz[3];
 917   if(argc != 3) naRuntimeError(c, "carttogeod() expects 3 arguments");
 918   for(int i=0; i<3; i++)
 919     xyz[i] = naNumValue(args[i]).num;
 920   sgCartToGeod(xyz, &lat, &lon, &alt);
 921   lat *= SG_RADIANS_TO_DEGREES;
 922   lon *= SG_RADIANS_TO_DEGREES;
 923   naRef vec = naNewVector(c);
 924   naVec_append(vec, naNum(lat));
 925   naVec_append(vec, naNum(lon));
 926   naVec_append(vec, naNum(alt));
 927   return vec;
 928 }
 929
 930 // Convert a geodetic lat/lon/altitude to a cartesian point.
 931 static naRef f_geodtocart(naContext c, naRef me, int argc, naRef* args)
 932 {
 933   if(argc != 3) naRuntimeError(c, "geodtocart() expects 3 arguments");
 934   double lat = naNumValue(args[0]).num * SG_DEGREES_TO_RADIANS;
 935   double lon = naNumValue(args[1]).num * SG_DEGREES_TO_RADIANS;
 936   double alt = naNumValue(args[2]).num;
 937   double xyz[3];
 938   sgGeodToCart(lat, lon, alt, xyz);
 939   naRef vec = naNewVector(c);
 940   naVec_append(vec, naNum(xyz[0]));
 941   naVec_append(vec, naNum(xyz[1]));
 942   naVec_append(vec, naNum(xyz[2]));
 943   return vec;
 944 }
 945
 946 // For given geodetic point return array with elevation, and a material data
 947 // hash, or nil if there's no information available (tile not loaded). If
 948 // information about the material isn't available, then nil is returned instead
 949 // of the hash.
 950 static naRef f_geodinfo(naContext c, naRef me, int argc, naRef* args)
 951 {
 952 #define HASHSET(s,l,n) naHash_set(matdata, naStr_fromdata(naNewString(c),s,l),n)
 953   if(argc < 2 || argc > 3)
 954     naRuntimeError(c, "geodinfo() expects 2 or 3 arguments: lat, lon [, maxalt]");
 955   double lat = naNumValue(args[0]).num;
 956   double lon = naNumValue(args[1]).num;
 957   double elev = argc == 3 ? naNumValue(args[2]).num : 10000;
 958   const simgear::BVHMaterial *material;
 959   SGGeod geod = SGGeod::fromDegM(lon, lat, elev);
 960   if(!globals->get_scenery()->get_elevation_m(geod, elev, &material))
 961     return naNil();
 962   const SGMaterial *mat = dynamic_cast<const SGMaterial *>(material);
 963   naRef vec = naNewVector(c);
 964   naVec_append(vec, naNum(elev));
 965   naRef matdata = naNil();
 966   if(mat) {
 967     matdata = naNewHash(c);
 968     naRef names = naNewVector(c);
 969     BOOST_FOREACH(const std::string& n, mat->get_names())
 970       naVec_append(names, stringToNasal(c, n));
 971
 972     HASHSET("names", 5, names);
 973     HASHSET("solid", 5, naNum(mat->get_solid()));
 974     HASHSET("friction_factor", 15, naNum(mat->get_friction_factor()));
 975     HASHSET("rolling_friction", 16, naNum(mat->get_rolling_friction()));
 976     HASHSET("load_resistance", 15, naNum(mat->get_load_resistance()));
 977     HASHSET("bumpiness", 9, naNum(mat->get_bumpiness()));
 978     HASHSET("light_coverage", 14, naNum(mat->get_light_coverage()));
 979   }
 980   naVec_append(vec, matdata);
 981   return vec;
 982 #undef HASHSET
 983 }
 984
 985
 986 // Returns data hash for particular or nearest airport of a <type>, or nil
 987 // on error.
 988 //
 989 // airportinfo(<id>);                   e.g. "KSFO"
 990 // airportinfo(<type>);                 type := ("airport"|"seaport"|"heliport")
 991 // airportinfo()                        same as  airportinfo("airport")
 992 // airportinfo(<lat>, <lon> [, <type>]);
 993 static naRef f_airportinfo(naContext c, naRef me, int argc, naRef* args)
 994 {
 995   SGGeod pos = globals->get_aircraft_position();
 996   FGAirport* apt = NULL;
 997
 998   if(argc >= 2 && naIsNum(args[0]) && naIsNum(args[1])) {
 999     pos = SGGeod::fromDeg(args[1].num, args[0].num);
1000     args += 2;
1001     argc -= 2;
1002   }
1003
1004   double maxRange = 10000.0; // expose this? or pick a smaller value?
1005
1006   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1007
1008   if(argc == 0) {
1009     // fall through and use AIRPORT
1010   } else if(argc == 1 && naIsString(args[0])) {
1011     if (filter.fromTypeString(naStr_data(args[0]))) {
1012       // done!
1013     } else {
1014       // user provided an <id>, hopefully
1015       apt = FGAirport::findByIdent(naStr_data(args[0]));
1016       if (!apt) {
1017         // return nil here, but don't raise a runtime error; this is a
1018         // legitamate way to validate an ICAO code, for example in a
1019         // dialog box or similar.
1020         return naNil();
1021       }
1022     }
1023   } else {
1024     naRuntimeError(c, "airportinfo() with invalid function arguments");
1025     return naNil();
1026   }
1027
1028   if(!apt) {
1029     apt = FGAirport::findClosest(pos, maxRange, &filter);
1030     if(!apt) return naNil();
1031   }
1032
1033   return ghostForAirport(c, apt);
1034 }
1035
1036 static naRef f_findAirportsWithinRange(naContext c, naRef me, int argc, naRef* args)
1037 {
1038   int argOffset = 0;
1039   SGGeod pos = globals->get_aircraft_position();
1040   argOffset += geodFromArgs(args, 0, argc, pos);
1041
1042   if (!naIsNum(args[argOffset])) {
1043     naRuntimeError(c, "findAirportsWithinRange expected range (in nm) as arg %d", argOffset);
1044   }
1045
1046   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1047   double rangeNm = args[argOffset++].num;
1048   if (argOffset < argc) {
1049     filter.fromTypeString(naStr_data(args[argOffset++]));
1050   }
1051
1052   naRef r = naNewVector(c);
1053
1054   FGPositioned::List apts = FGPositioned::findWithinRange(pos, rangeNm, &filter);
1055   FGPositioned::sortByRange(apts, pos);
1056
1057   BOOST_FOREACH(FGPositionedRef a, apts) {
1058     FGAirport* apt = (FGAirport*) a.get();
1059     naVec_append(r, ghostForAirport(c, apt));
1060   }
1061
1062   return r;
1063 }
1064
1065 static naRef f_findAirportsByICAO(naContext c, naRef me, int argc, naRef* args)
1066 {
1067   if (!naIsString(args[0])) {
1068     naRuntimeError(c, "findAirportsByICAO expects string as arg 0");
1069   }
1070
1071   int argOffset = 0;
1072   std::string prefix(naStr_data(args[argOffset++]));
1073   FGAirport::TypeRunwayFilter filter; // defaults to airports only
1074   if (argOffset < argc) {
1075     filter.fromTypeString(naStr_data(args[argOffset++]));
1076   }
1077
1078   naRef r = naNewVector(c);
1079
1080   FGPositioned::List apts = FGPositioned::findAllWithIdent(prefix, &filter, false);
1081
1082   BOOST_FOREACH(FGPositionedRef a, apts) {
1083     FGAirport* apt = (FGAirport*) a.get();
1084     naVec_append(r, ghostForAirport(c, apt));
1085   }
1086
1087   return r;
1088 }
1089
1090 static naRef f_airport_tower(naContext c, naRef me, int argc, naRef* args)
1091 {
1092     FGAirport* apt = airportGhost(me);
1093     if (!apt) {
1094       naRuntimeError(c, "airport.tower called on non-airport object");
1095     }
1096
1097     // build a hash for the tower position
1098     SGGeod towerLoc = apt->getTowerLocation();
1099     naRef tower = naNewHash(c);
1100     hashset(c, tower, "lat", naNum(towerLoc.getLatitudeDeg()));
1101     hashset(c, tower, "lon", naNum(towerLoc.getLongitudeDeg()));
1102     hashset(c, tower, "elevation", naNum(towerLoc.getElevationM()));
1103     return tower;
1104 }
1105
1106 static naRef f_airport_comms(naContext c, naRef me, int argc, naRef* args)
1107 {
1108     FGAirport* apt = airportGhost(me);
1109     if (!apt) {
1110       naRuntimeError(c, "airport.comms called on non-airport object");
1111     }
1112     naRef comms = naNewVector(c);
1113
1114 // if we have an explicit type, return a simple vector of frequencies
1115     if (argc > 0 && naIsScalar(args[0])) {
1116         std::string commName = naStr_data(args[0]);
1117         FGPositioned::Type commType = FGPositioned::typeFromName(commName);
1118
1119         BOOST_FOREACH(flightgear::CommStation* comm, apt->commStationsOfType(commType)) {
1120             naVec_append(comms, naNum(comm->freqMHz()));
1121         }
1122     } else {
1123 // otherwise return a vector of hashes, one for each comm station.
1124         BOOST_FOREACH(flightgear::CommStation* comm, apt->commStations()) {
1125             naRef commHash = naNewHash(c);
1126             hashset(c, commHash, "frequency", naNum(comm->freqMHz()));
1127             hashset(c, commHash, "ident", stringToNasal(c, comm->ident()));
1128             naVec_append(comms, commHash);
1129         }
1130     }
1131
1132     return comms;
1133 }
1134
1135 static naRef f_airport_runway(naContext c, naRef me, int argc, naRef* args)
1136 {
1137   FGAirport* apt = airportGhost(me);
1138   if (!apt) {
1139     naRuntimeError(c, "airport.runway called on non-airport object");
1140   }
1141
1142   if ((argc < 1) || !naIsString(args[0])) {
1143     naRuntimeError(c, "airport.runway expects a runway ident argument");
1144   }
1145
1146   std::string ident(naStr_data(args[0]));
1147   boost::to_upper(ident);
1148
1149   if (apt->hasRunwayWithIdent(ident)) {
1150     return ghostForRunway(c, apt->getRunwayByIdent(ident));
1151   } else if (apt->hasHelipadWithIdent(ident)) {
1152     return ghostForHelipad(c, apt->getHelipadByIdent(ident));
1153   }
1154   return naNil();
1155 }
1156
1157 static naRef f_airport_runwaysWithoutReciprocals(naContext c, naRef me, int argc, naRef* args)
1158 {
1159   FGAirport* apt = airportGhost(me);
1160   if (!apt) {
1161     naRuntimeError(c, "airport.runwaysWithoutReciprocals called on non-airport object");
1162   }
1163
1164   FGRunwayList rwylist(apt->getRunwaysWithoutReciprocals());
1165   naRef runways = naNewVector(c);
1166   for (unsigned int r=0; r<rwylist.size(); ++r) {
1167     FGRunway* rwy(rwylist[r]);
1168     naVec_append(runways, ghostForRunway(c, apt->getRunwayByIdent(rwy->ident())));
1169   }
1170   return runways;
1171 }
1172
1173 static naRef f_airport_sids(naContext c, naRef me, int argc, naRef* args)
1174 {
1175   FGAirport* apt = airportGhost(me);
1176   if (!apt) {
1177     naRuntimeError(c, "airport.sids called on non-airport object");
1178   }
1179
1180   naRef sids = naNewVector(c);
1181
1182   FGRunway* rwy = NULL;
1183   if (argc > 0 && naIsString(args[0])) {
1184     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1185       return naNil();
1186     }
1187
1188     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1189   } else if (argc > 0) {
1190     rwy = runwayGhost(args[0]);
1191   }
1192
1193   if (rwy) {
1194     BOOST_FOREACH(flightgear::SID* sid, rwy->getSIDs()) {
1195       naRef procId = stringToNasal(c, sid->ident());
1196       naVec_append(sids, procId);
1197     }
1198   } else {
1199     for (unsigned int s=0; s<apt->numSIDs(); ++s) {
1200       flightgear::SID* sid = apt->getSIDByIndex(s);
1201       naRef procId = stringToNasal(c, sid->ident());
1202       naVec_append(sids, procId);
1203     }
1204   }
1205
1206   return sids;
1207 }
1208
1209 static naRef f_airport_stars(naContext c, naRef me, int argc, naRef* args)
1210 {
1211   FGAirport* apt = airportGhost(me);
1212   if (!apt) {
1213     naRuntimeError(c, "airport.stars called on non-airport object");
1214   }
1215
1216   naRef stars = naNewVector(c);
1217
1218   FGRunway* rwy = NULL;
1219   if (argc > 0 && naIsString(args[0])) {
1220     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1221       return naNil();
1222     }
1223
1224     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1225   } else if (argc > 0) {
1226     rwy = runwayGhost(args[0]);
1227   }
1228
1229   if (rwy) {
1230     BOOST_FOREACH(flightgear::STAR* s, rwy->getSTARs()) {
1231       naRef procId = stringToNasal(c, s->ident());
1232       naVec_append(stars, procId);
1233     }
1234   } else {
1235     for (unsigned int s=0; s<apt->numSTARs(); ++s) {
1236       flightgear::STAR* star = apt->getSTARByIndex(s);
1237       naRef procId = stringToNasal(c, star->ident());
1238       naVec_append(stars, procId);
1239     }
1240   }
1241
1242   return stars;
1243 }
1244
1245 static naRef f_airport_approaches(naContext c, naRef me, int argc, naRef* args)
1246 {
1247   FGAirport* apt = airportGhost(me);
1248   if (!apt) {
1249     naRuntimeError(c, "airport.getApproachList called on non-airport object");
1250   }
1251
1252   naRef approaches = naNewVector(c);
1253
1254   ProcedureType ty = PROCEDURE_INVALID;
1255   if ((argc > 1) && naIsString(args[1])) {
1256     std::string u(naStr_data(args[1]));
1257     boost::to_upper(u);
1258     if (u == "NDB") ty = PROCEDURE_APPROACH_NDB;
1259     if (u == "VOR") ty = PROCEDURE_APPROACH_VOR;
1260     if (u == "ILS") ty = PROCEDURE_APPROACH_ILS;
1261     if (u == "RNAV") ty = PROCEDURE_APPROACH_RNAV;
1262   }
1263
1264   FGRunway* rwy = NULL;
1265   if (argc > 0 && (rwy = runwayGhost(args[0]))) {
1266     // ok
1267   } else if (argc > 0 && naIsString(args[0])) {
1268     if (!apt->hasRunwayWithIdent(naStr_data(args[0]))) {
1269       return naNil();
1270     }
1271
1272     rwy = apt->getRunwayByIdent(naStr_data(args[0]));
1273   }
1274
1275   if (rwy) {
1276     BOOST_FOREACH(Approach* s, rwy->getApproaches()) {
1277       if ((ty != PROCEDURE_INVALID) && (s->type() != ty)) {
1278         continue;
1279       }
1280
1281       naRef procId = stringToNasal(c, s->ident());
1282       naVec_append(approaches, procId);
1283     }
1284   } else {
1285     // no runway specified, report them all
1286     for (unsigned int s=0; s<apt->numApproaches(); ++s) {
1287       Approach* app = apt->getApproachByIndex(s);
1288       if ((ty != PROCEDURE_INVALID) && (app->type() != ty)) {
1289         continue;
1290       }
1291
1292       naRef procId = stringToNasal(c, app->ident());
1293       naVec_append(approaches, procId);
1294     }
1295   }
1296
1297   return approaches;
1298 }
1299
1300 static naRef f_airport_parking(naContext c, naRef me, int argc, naRef* args)
1301 {
1302   FGAirport* apt = airportGhost(me);
1303   if (!apt) {
1304     naRuntimeError(c, "airport.parking called on non-airport object");
1305   }
1306
1307   naRef r = naNewVector(c);
1308   std::string type;
1309   bool onlyAvailable = false;
1310
1311   if (argc > 0 && naIsString(args[0])) {
1312     type = naStr_data(args[0]);
1313   }
1314
1315   if ((argc > 1) && naIsNum(args[1])) {
1316     onlyAvailable = (args[1].num != 0.0);
1317   }
1318
1319   FGAirportDynamics* dynamics = apt->getDynamics();
1320   PositionedIDVec parkings = flightgear::NavDataCache::instance()->airportItemsOfType(apt->guid(),
1321                                                                                       FGPositioned::PARKING);
1322
1323   BOOST_FOREACH(PositionedID parking, parkings) {
1324     // filter out based on availability and type
1325     if (onlyAvailable && !dynamics->isParkingAvailable(parking)) {
1326       continue;
1327     }
1328
1329     FGParking* park = dynamics->getParking(parking);
1330     if (!type.empty() && (park->getType() != type)) {
1331       continue;
1332     }
1333
1334     const SGGeod& parkLoc = park->geod();
1335     naRef ph = naNewHash(c);
1336     hashset(c, ph, "name", stringToNasal(c, park->getName()));
1337     hashset(c, ph, "lat", naNum(parkLoc.getLatitudeDeg()));
1338     hashset(c, ph, "lon", naNum(parkLoc.getLongitudeDeg()));
1339     hashset(c, ph, "elevation", naNum(parkLoc.getElevationM()));
1340     naVec_append(r, ph);
1341   }
1342
1343   return r;
1344 }
1345
1346 static naRef f_airport_getSid(naContext c, naRef me, int argc, naRef* args)
1347 {
1348   FGAirport* apt = airportGhost(me);
1349   if (!apt) {
1350     naRuntimeError(c, "airport.getSid called on non-airport object");
1351   }
1352
1353   if ((argc != 1) || !naIsString(args[0])) {
1354     naRuntimeError(c, "airport.getSid passed invalid argument");
1355   }
1356
1357   std::string ident = naStr_data(args[0]);
1358   return ghostForProcedure(c, apt->findSIDWithIdent(ident));
1359 }
1360
1361 static naRef f_airport_getStar(naContext c, naRef me, int argc, naRef* args)
1362 {
1363   FGAirport* apt = airportGhost(me);
1364   if (!apt) {
1365     naRuntimeError(c, "airport.getStar called on non-airport object");
1366   }
1367
1368   if ((argc != 1) || !naIsString(args[0])) {
1369     naRuntimeError(c, "airport.getStar passed invalid argument");
1370   }
1371
1372   std::string ident = naStr_data(args[0]);
1373   return ghostForProcedure(c, apt->findSTARWithIdent(ident));
1374 }
1375
1376 static naRef f_airport_getApproach(naContext c, naRef me, int argc, naRef* args)
1377 {
1378   FGAirport* apt = airportGhost(me);
1379   if (!apt) {
1380     naRuntimeError(c, "airport.getIAP called on non-airport object");
1381   }
1382
1383   if ((argc != 1) || !naIsString(args[0])) {
1384     naRuntimeError(c, "airport.getIAP passed invalid argument");
1385   }
1386
1387   std::string ident = naStr_data(args[0]);
1388   return ghostForProcedure(c, apt->findApproachWithIdent(ident));
1389 }
1390
1391 static naRef f_airport_toString(naContext c, naRef me, int argc, naRef* args)
1392 {
1393   FGAirport* apt = airportGhost(me);
1394   if (!apt) {
1395     naRuntimeError(c, "airport.tostring called on non-airport object");
1396   }
1397
1398   return stringToNasal(c, "an airport " + apt->ident());
1399 }
1400
1401 // Returns vector of data hash for navaid of a <type>, nil on error
1402 // navaids sorted by ascending distance
1403 // navinfo([<lat>,<lon>],[<type>],[<id>])
1404 // lat/lon (numeric): use latitude/longitude instead of ac position
1405 // type:              ("fix"|"vor"|"ndb"|"ils"|"dme"|"tacan"|"any")
1406 // id:                (partial) id of the fix
1407 // examples:
1408 // navinfo("vor")     returns all vors
1409 // navinfo("HAM")     return all navaids who's name start with "HAM"
1410 // navinfo("vor", "HAM") return all vor who's name start with "HAM"
1411 //navinfo(34,48,"vor","HAM") return all vor who's name start with "HAM"
1412 //                           sorted by distance relative to lat=34, lon=48
1413 static naRef f_navinfo(naContext c, naRef me, int argc, naRef* args)
1414 {
1415   SGGeod pos;
1416
1417   if(argc >= 2 && naIsNum(args[0]) && naIsNum(args[1])) {
1418     pos = SGGeod::fromDeg(args[1].num, args[0].num);
1419     args += 2;
1420     argc -= 2;
1421   } else {
1422     pos = globals->get_aircraft_position();
1423   }
1424
1425   FGPositioned::Type type = FGPositioned::INVALID;
1426   nav_list_type navlist;
1427   const char * id = "";
1428
1429   if(argc > 0 && naIsString(args[0])) {
1430     const char *s = naStr_data(args[0]);
1431     if(!strcmp(s, "any")) type = FGPositioned::INVALID;
1432     else if(!strcmp(s, "fix")) type = FGPositioned::FIX;
1433     else if(!strcmp(s, "vor")) type = FGPositioned::VOR;
1434     else if(!strcmp(s, "ndb")) type = FGPositioned::NDB;
1435     else if(!strcmp(s, "ils")) type = FGPositioned::ILS;
1436     else if(!strcmp(s, "dme")) type = FGPositioned::DME;
1437     else if(!strcmp(s, "tacan")) type = FGPositioned::TACAN;
1438     else id = s; // this is an id
1439     ++args;
1440     --argc;
1441   }
1442
1443   if(argc > 0 && naIsString(args[0])) {
1444     if( *id != 0 ) {
1445       naRuntimeError(c, "navinfo() called with navaid id");
1446       return naNil();
1447     }
1448     id = naStr_data(args[0]);
1449     ++args;
1450     --argc;
1451   }
1452
1453   if( argc > 0 ) {
1454     naRuntimeError(c, "navinfo() called with too many arguments");
1455     return naNil();
1456   }
1457
1458   FGNavList::TypeFilter filter(type);
1459   navlist = FGNavList::findByIdentAndFreq( pos, id, 0.0, &filter );
1460
1461   naRef reply = naNewVector(c);
1462   for( nav_list_type::const_iterator it = navlist.begin(); it != navlist.end(); ++it ) {
1463     naVec_append( reply, ghostForNavaid(c, *it) );
1464   }
1465   return reply;
1466 }
1467
1468 static naRef f_findNavaidsWithinRange(naContext c, naRef me, int argc, naRef* args)
1469 {
1470   int argOffset = 0;
1471   SGGeod pos = globals->get_aircraft_position();
1472   argOffset += geodFromArgs(args, 0, argc, pos);
1473
1474   if (!naIsNum(args[argOffset])) {
1475     naRuntimeError(c, "findNavaidsWithinRange expected range (in nm) as arg %d", argOffset);
1476   }
1477
1478   FGPositioned::Type type = FGPositioned::INVALID;
1479   double rangeNm = args[argOffset++].num;
1480   if (argOffset < argc) {
1481     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1482   }
1483
1484   naRef r = naNewVector(c);
1485   FGNavList::TypeFilter filter(type);
1486   FGPositioned::List navs = FGPositioned::findWithinRange(pos, rangeNm, &filter);
1487   FGPositioned::sortByRange(navs, pos);
1488
1489   BOOST_FOREACH(FGPositionedRef a, navs) {
1490     FGNavRecord* nav = (FGNavRecord*) a.get();
1491     naVec_append(r, ghostForNavaid(c, nav));
1492   }
1493
1494   return r;
1495 }
1496
1497 static naRef f_findNavaidByFrequency(naContext c, naRef me, int argc, naRef* args)
1498 {
1499   int argOffset = 0;
1500   SGGeod pos = globals->get_aircraft_position();
1501   argOffset += geodFromArgs(args, 0, argc, pos);
1502
1503   if (!naIsNum(args[argOffset])) {
1504     naRuntimeError(c, "findNavaidByFrequency expectes frequency (in Mhz) as arg %d", argOffset);
1505   }
1506
1507   FGPositioned::Type type = FGPositioned::INVALID;
1508   double freqMhz = args[argOffset++].num;
1509   if (argOffset < argc) {
1510     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1511   }
1512
1513   FGNavList::TypeFilter filter(type);
1514   nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
1515   if (navs.empty()) {
1516     return naNil();
1517   }
1518
1519   return ghostForNavaid(c, navs.front().ptr());
1520 }
1521
1522 static naRef f_findNavaidsByFrequency(naContext c, naRef me, int argc, naRef* args)
1523 {
1524   int argOffset = 0;
1525   SGGeod pos = globals->get_aircraft_position();
1526   argOffset += geodFromArgs(args, 0, argc, pos);
1527
1528   if (!naIsNum(args[argOffset])) {
1529     naRuntimeError(c, "findNavaidsByFrequency expectes frequency (in Mhz) as arg %d", argOffset);
1530   }
1531
1532   FGPositioned::Type type = FGPositioned::INVALID;
1533   double freqMhz = args[argOffset++].num;
1534   if (argOffset < argc) {
1535     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1536   }
1537
1538   naRef r = naNewVector(c);
1539
1540   FGNavList::TypeFilter filter(type);
1541   nav_list_type navs = FGNavList::findAllByFreq(freqMhz, pos, &filter);
1542
1543   BOOST_FOREACH(nav_rec_ptr a, navs) {
1544     naVec_append(r, ghostForNavaid(c, a.ptr()));
1545   }
1546
1547   return r;
1548 }
1549
1550 static naRef f_findNavaidsByIdent(naContext c, naRef me, int argc, naRef* args)
1551 {
1552   int argOffset = 0;
1553   SGGeod pos = globals->get_aircraft_position();
1554   argOffset += geodFromArgs(args, 0, argc, pos);
1555
1556   if (!naIsString(args[argOffset])) {
1557     naRuntimeError(c, "findNavaidsByIdent expectes ident string as arg %d", argOffset);
1558   }
1559
1560   FGPositioned::Type type = FGPositioned::INVALID;
1561   std::string ident = naStr_data(args[argOffset++]);
1562   if (argOffset < argc) {
1563     type = FGPositioned::typeFromName(naStr_data(args[argOffset]));
1564   }
1565
1566   FGNavList::TypeFilter filter(type);
1567   naRef r = naNewVector(c);
1568   nav_list_type navs = FGNavList::findByIdentAndFreq(pos, ident, 0.0, &filter);
1569
1570   BOOST_FOREACH(nav_rec_ptr a, navs) {
1571     naVec_append(r, ghostForNavaid(c, a.ptr()));
1572   }
1573
1574   return r;
1575 }
1576
1577 static naRef f_findFixesByIdent(naContext c, naRef me, int argc, naRef* args)
1578 {
1579   int argOffset = 0;
1580   SGGeod pos = globals->get_aircraft_position();
1581   argOffset += geodFromArgs(args, 0, argc, pos);
1582
1583   if (!naIsString(args[argOffset])) {
1584     naRuntimeError(c, "findFixesByIdent expectes ident string as arg %d", argOffset);
1585   }
1586
1587   std::string ident(naStr_data(args[argOffset]));
1588   naRef r = naNewVector(c);
1589
1590   FGPositioned::TypeFilter filter(FGPositioned::FIX);
1591   FGPositioned::List fixes = FGPositioned::findAllWithIdent(ident, &filter);
1592   FGPositioned::sortByRange(fixes, pos);
1593
1594   BOOST_FOREACH(FGPositionedRef f, fixes) {
1595     naVec_append(r, ghostForFix(c, (FGFix*) f.ptr()));
1596   }
1597
1598   return r;
1599 }
1600
1601 // Convert a cartesian point to a geodetic lat/lon/altitude.
1602 static naRef f_magvar(naContext c, naRef me, int argc, naRef* args)
1603 {
1604   SGGeod pos = globals->get_aircraft_position();
1605   if (argc == 0) {
1606     // fine, use aircraft position
1607   } else if (geodFromArgs(args, 0, argc, pos)) {
1608     // okay
1609   } else {
1610     naRuntimeError(c, "magvar() expects no arguments, a positioned hash or lat,lon pair");
1611   }
1612
1613   double jd = globals->get_time_params()->getJD();
1614   double magvarDeg = sgGetMagVar(pos, jd) * SG_RADIANS_TO_DEGREES;
1615   return naNum(magvarDeg);
1616 }
1617
1618 static naRef f_courseAndDistance(naContext c, naRef me, int argc, naRef* args)
1619 {
1620     SGGeod from = globals->get_aircraft_position(), to, p;
1621     int argOffset = geodFromArgs(args, 0, argc, p);
1622     if (geodFromArgs(args, argOffset, argc, to)) {
1623       from = p; // we parsed both FROM and TO args, so first was from
1624     } else {
1625       to = p; // only parsed one arg, so FROM is current
1626     }
1627
1628     if (argOffset == 0) {
1629         naRuntimeError(c, "invalid arguments to courseAndDistance");
1630     }
1631
1632     double course, course2, d;
1633     SGGeodesy::inverse(from, to, course, course2, d);
1634
1635     naRef result = naNewVector(c);
1636     naVec_append(result, naNum(course));
1637     naVec_append(result, naNum(d * SG_METER_TO_NM));
1638     return result;
1639 }
1640
1641 static naRef f_greatCircleMove(naContext c, naRef me, int argc, naRef* args)
1642 {
1643   SGGeod from = globals->get_aircraft_position(), to;
1644   int argOffset = 0;
1645
1646   // complication - don't inerpret two doubles (as the only args)
1647   // as a lat,lon pair - only do so if we have at least three args.
1648   if (argc > 2) {
1649     argOffset = geodFromArgs(args, 0, argc, from);
1650   }
1651
1652   if ((argOffset + 1) >= argc) {
1653     naRuntimeError(c, "isufficent arguments to greatCircleMove");
1654   }
1655
1656   if (!naIsNum(args[argOffset]) || !naIsNum(args[argOffset+1])) {
1657     naRuntimeError(c, "invalid arguments %d and %d to greatCircleMove",
1658                    argOffset, argOffset + 1);
1659   }
1660
1661   double course = args[argOffset].num, course2;
1662   double distanceNm = args[argOffset + 1].num;
1663   SGGeodesy::direct(from, course, distanceNm * SG_NM_TO_METER, to, course2);
1664
1665   // return geo.Coord
1666   naRef coord = naNewHash(c);
1667   hashset(c, coord, "lat", naNum(to.getLatitudeDeg()));
1668   hashset(c, coord, "lon", naNum(to.getLongitudeDeg()));
1669   return coord;
1670 }
1671
1672 static naRef f_tilePath(naContext c, naRef me, int argc, naRef* args)
1673 {
1674     SGGeod pos = globals->get_aircraft_position();
1675     geodFromArgs(args, 0, argc, pos);
1676     SGBucket b(pos);
1677     return stringToNasal(c, b.gen_base_path());
1678 }
1679
1680 static naRef f_tileIndex(naContext c, naRef me, int argc, naRef* args)
1681 {
1682   SGGeod pos = globals->get_aircraft_position();
1683   geodFromArgs(args, 0, argc, pos);
1684   SGBucket b(pos);
1685   return naNum(b.gen_index());
1686 }
1687
1688 static naRef f_route(naContext c, naRef me, int argc, naRef* args)
1689 {
1690   if (argc == 0) {
1691     FGRouteMgr* rm = static_cast<FGRouteMgr*>(globals->get_subsystem("route-manager"));
1692     return ghostForFlightPlan(c, rm->flightPlan());
1693   }
1694
1695   if ((argc > 0) && naIsString(args[0])) {
1696     flightgear::FlightPlan* fp = new flightgear::FlightPlan;
1697     SGPath path(naStr_data(args[0]));
1698     if (!path.exists()) {
1699       naRuntimeError(c, "flightplan, no file at path %s", path.c_str());
1700     }
1701
1702     if (!fp->load(path)) {
1703       SG_LOG(SG_NASAL, SG_WARN, "failed to load flight-plan from " << path);
1704       delete fp;
1705       return naNil();
1706     }
1707
1708     return ghostForFlightPlan(c, fp);
1709   }
1710
1711   naRuntimeError(c, "bad arguments to flightplan()");
1712   return naNil();
1713 }
1714
1715 class NasalFPDelegate : public FlightPlan::Delegate
1716 {
1717 public:
1718   NasalFPDelegate(FlightPlan* fp, FGNasalSys* sys, naRef ins) :
1719     _nasal(sys),
1720     _plan(fp),
1721     _instance(ins)
1722   {
1723     SG_LOG(SG_NASAL, SG_INFO, "created Nasal delegate for " << fp);
1724     _gcSaveKey = _nasal->gcSave(ins);
1725   }
1726
1727   virtual ~NasalFPDelegate()
1728   {
1729     SG_LOG(SG_NASAL, SG_INFO, "destroying Nasal delegate for " << _plan);
1730     _nasal->gcRelease(_gcSaveKey);
1731   }
1732
1733   virtual void departureChanged()
1734   {
1735     callDelegateMethod("departureChanged");
1736   }
1737
1738   virtual void arrivalChanged()
1739   {
1740     callDelegateMethod("arrivalChanged");
1741   }
1742
1743   virtual void waypointsChanged()
1744   {
1745     callDelegateMethod("waypointsChanged");
1746   }
1747
1748   virtual void currentWaypointChanged()
1749   {
1750     callDelegateMethod("currentWaypointChanged");
1751   }
1752
1753   virtual void cleared()
1754   {
1755     callDelegateMethod("cleared");
1756   }
1757 private:
1758
1759   void callDelegateMethod(const char* method)
1760   {
1761     naRef f;
1762     naMember_cget(_nasal->context(), _instance, method, &f);
1763     if (naIsNil(f)) {
1764       return; // no method on the delegate
1765     }
1766
1767     naRef arg[1];
1768     arg[0] = ghostForFlightPlan(_nasal->context(), _plan);
1769     _nasal->callMethod(f, _instance, 1, arg, naNil());
1770   }
1771
1772   FGNasalSys* _nasal;
1773   FlightPlan* _plan;
1774   naRef _instance;
1775   int _gcSaveKey;
1776 };
1777
1778 class NasalFPDelegateFactory : public FlightPlan::DelegateFactory
1779 {
1780 public:
1781   NasalFPDelegateFactory(naRef code)
1782   {
1783     _nasal = (FGNasalSys*) globals->get_subsystem("nasal");
1784     _func = code;
1785     _gcSaveKey = _nasal->gcSave(_func);
1786   }
1787
1788   ~NasalFPDelegateFactory()
1789   {
1790     _nasal->gcRelease(_gcSaveKey);
1791   }
1792
1793   virtual FlightPlan::Delegate* createFlightPlanDelegate(FlightPlan* fp)
1794   {
1795     naRef args[1];
1796     args[0] = ghostForFlightPlan(_nasal->context(), fp);
1797     naRef instance = _nasal->call(_func, 1, args, naNil());
1798     if (naIsNil(instance)) {
1799       return NULL;
1800     }
1801
1802     return new NasalFPDelegate(fp, _nasal, instance);
1803   }
1804 private:
1805   FGNasalSys* _nasal;
1806   naRef _func;
1807   int _gcSaveKey;
1808 };
1809
1810 static naRef f_registerFPDelegate(naContext c, naRef me, int argc, naRef* args)
1811 {
1812   if ((argc < 1) || !naIsFunc(args[0])) {
1813     naRuntimeError(c, "non-function argument to registerFlightPlanDelegate");
1814   }
1815
1816   NasalFPDelegateFactory* factory = new NasalFPDelegateFactory(args[0]);
1817   FlightPlan::registerDelegateFactory(factory);
1818
1819   return naNil();
1820 }
1821
1822 static WayptRef wayptFromArg(naRef arg)
1823 {
1824   WayptRef r = wayptGhost(arg);
1825   if (r.valid()) {
1826     return r;
1827   }
1828
1829   FGPositioned* pos = positionedGhost(arg);
1830   if (!pos) {
1831     // let's check if the arg is hash, coudl extra a geod and hence build
1832     // a simple waypoint
1833
1834     return WayptRef();
1835   }
1836
1837 // special-case for runways
1838   if (pos->type() == FGPositioned::RUNWAY) {
1839     return new RunwayWaypt((FGRunway*) pos, NULL);
1840   }
1841
1842   return new NavaidWaypoint(pos, NULL);
1843 }
1844
1845 static naRef convertWayptVecToNasal(naContext c, const WayptVec& wps)
1846 {
1847   naRef result = naNewVector(c);
1848   BOOST_FOREACH(WayptRef wpt, wps) {
1849     naVec_append(result, ghostForWaypt(c, wpt.get()));
1850   }
1851   return result;
1852 }
1853
1854 static naRef f_airwaySearch(naContext c, naRef me, int argc, naRef* args)
1855 {
1856   if (argc < 2) {
1857     naRuntimeError(c, "airwaysSearch needs at least two arguments");
1858   }
1859
1860   WayptRef start = wayptFromArg(args[0]),
1861     end = wayptFromArg(args[1]);
1862
1863   if (!start || !end) {
1864     SG_LOG(SG_NASAL, SG_WARN, "airwaysSearch: start or end points are invalid");
1865     return naNil();
1866   }
1867
1868   bool highLevel = true;
1869   if ((argc > 2) && naIsString(args[2])) {
1870     if (!strcmp(naStr_data(args[2]), "lowlevel")) {
1871       highLevel = false;
1872     }
1873   }
1874
1875   WayptVec route;
1876   if (highLevel) {
1877     Airway::highLevel()->route(start, end, route);
1878   } else {
1879     Airway::lowLevel()->route(start, end, route);
1880   }
1881
1882   return convertWayptVecToNasal(c, route);
1883 }
1884
1885 static naRef f_createWP(naContext c, naRef me, int argc, naRef* args)
1886 {
1887   SGGeod pos;
1888   int argOffset = geodFromArgs(args, 0, argc, pos);
1889
1890   if (((argc - argOffset) < 1) || !naIsString(args[argOffset])) {
1891     naRuntimeError(c, "createWP: no identifier supplied");
1892   }
1893
1894   std::string ident = naStr_data(args[argOffset++]);
1895   WayptRef wpt = new BasicWaypt(pos, ident, NULL);
1896
1897 // set waypt flags - approach, departure, pseudo, etc
1898   if (argc > argOffset) {
1899     WayptFlag f = wayptFlagFromString(naStr_data(args[argOffset++]));
1900     wpt->setFlag(f);
1901   }
1902
1903   return ghostForWaypt(c, wpt);
1904 }
1905
1906 static naRef f_createWPFrom(naContext c, naRef me, int argc, naRef* args)
1907 {
1908   if (argc < 1) {
1909     naRuntimeError(c, "createWPFrom: need at least one argument");
1910   }
1911
1912   FGPositioned* positioned = positionedGhost(args[0]);
1913   if (!positioned) {
1914     naRuntimeError(c, "createWPFrom: couldn;t convert arg[0] to FGPositioned");
1915   }
1916
1917   WayptRef wpt;
1918   if (positioned->type() == FGPositioned::RUNWAY) {
1919     wpt = new RunwayWaypt((FGRunway*) positioned, NULL);
1920   } else {
1921     wpt = new NavaidWaypoint(positioned, NULL);
1922   }
1923
1924   // set waypt flags - approach, departure, pseudo, etc
1925   if (argc > 1) {
1926     WayptFlag f = wayptFlagFromString(naStr_data(args[1]));
1927     wpt->setFlag(f);
1928   }
1929
1930   return ghostForWaypt(c, wpt);
1931 }
1932
1933 static naRef f_flightplan_getWP(naContext c, naRef me, int argc, naRef* args)
1934 {
1935   FlightPlan* fp = flightplanGhost(me);
1936   if (!fp) {
1937     naRuntimeError(c, "flightplan.getWP called on non-flightplan object");
1938   }
1939
1940   int index;
1941   if (argc == 0) {
1942     index = fp->currentIndex();
1943   } else {
1944     index = (int) naNumValue(args[0]).num;
1945   }
1946
1947   if ((index < 0) || (index >= fp->numLegs())) {
1948     return naNil();
1949   }
1950
1951   return ghostForLeg(c, fp->legAtIndex(index));
1952 }
1953
1954 static naRef f_flightplan_currentWP(naContext c, naRef me, int argc, naRef* args)
1955 {
1956   FlightPlan* fp = flightplanGhost(me);
1957   if (!fp) {
1958     naRuntimeError(c, "flightplan.currentWP called on non-flightplan object");
1959   }
1960   return ghostForLeg(c, fp->currentLeg());
1961 }
1962
1963 static naRef f_flightplan_nextWP(naContext c, naRef me, int argc, naRef* args)
1964 {
1965   FlightPlan* fp = flightplanGhost(me);
1966   if (!fp) {
1967     naRuntimeError(c, "flightplan.nextWP called on non-flightplan object");
1968   }
1969   return ghostForLeg(c, fp->nextLeg());
1970 }
1971
1972 static naRef f_flightplan_numWaypoints(naContext c, naRef me, int argc, naRef* args)
1973 {
1974   FlightPlan* fp = flightplanGhost(me);
1975   if (!fp) {
1976     naRuntimeError(c, "flightplan.numWaypoints called on non-flightplan object");
1977   }
1978   return naNum(fp->numLegs());
1979 }
1980
1981 static naRef f_flightplan_appendWP(naContext c, naRef me, int argc, naRef* args)
1982 {
1983   FlightPlan* fp = flightplanGhost(me);
1984   if (!fp) {
1985     naRuntimeError(c, "flightplan.appendWP called on non-flightplan object");
1986   }
1987
1988   WayptRef wp = wayptGhost(args[0]);
1989   int index = fp->numLegs();
1990   fp->insertWayptAtIndex(wp.get(), index);
1991   return naNum(index);
1992 }
1993
1994 static naRef f_flightplan_insertWP(naContext c, naRef me, int argc, naRef* args)
1995 {
1996   FlightPlan* fp = flightplanGhost(me);
1997   if (!fp) {
1998     naRuntimeError(c, "flightplan.insertWP called on non-flightplan object");
1999   }
2000
2001   WayptRef wp = wayptGhost(args[0]);
2002   int index = -1; // append
2003   if ((argc > 1) && naIsNum(args[1])) {
2004     index = (int) args[1].num;
2005   }
2006
2007   fp->insertWayptAtIndex(wp.get(), index);
2008   return naNil();
2009 }
2010
2011 static naRef f_flightplan_insertWPAfter(naContext c, naRef me, int argc, naRef* args)
2012 {
2013   FlightPlan* fp = flightplanGhost(me);
2014   if (!fp) {
2015     naRuntimeError(c, "flightplan.insertWPAfter called on non-flightplan object");
2016   }
2017
2018   WayptRef wp = wayptGhost(args[0]);
2019   int index = -1; // append
2020   if ((argc > 1) && naIsNum(args[1])) {
2021     index = (int) args[1].num;
2022   }
2023
2024   fp->insertWayptAtIndex(wp.get(), index + 1);
2025   return naNil();
2026 }
2027
2028 static naRef f_flightplan_insertWaypoints(naContext c, naRef me, int argc, naRef* args)
2029 {
2030   FlightPlan* fp = flightplanGhost(me);
2031   if (!fp) {
2032     naRuntimeError(c, "flightplan.insertWaypoints called on non-flightplan object");
2033   }
2034
2035   WayptVec wps;
2036   if (!naIsVector(args[0])) {
2037     naRuntimeError(c, "flightplan.insertWaypoints expects vector as first arg");
2038   }
2039
2040   int count = naVec_size(args[0]);
2041   for (int i=0; i<count; ++i) {
2042     Waypt* wp = wayptGhost(naVec_get(args[0], i));
2043     if (wp) {
2044       wps.push_back(wp);
2045     }
2046   }
2047
2048   int index = -1; // append
2049   if ((argc > 1) && naIsNum(args[1])) {
2050     index = (int) args[1].num;
2051   }
2052
2053   fp->insertWayptsAtIndex(wps, index);
2054   return naNil();
2055 }
2056
2057 static naRef f_flightplan_deleteWP(naContext c, naRef me, int argc, naRef* args)
2058 {
2059   FlightPlan* fp = flightplanGhost(me);
2060   if (!fp) {
2061     naRuntimeError(c, "flightplan.deleteWP called on non-flightplan object");
2062   }
2063
2064   if ((argc < 1) || !naIsNum(args[0])) {
2065     naRuntimeError(c, "bad argument to flightplan.deleteWP");
2066   }
2067
2068   int index = (int) args[0].num;
2069   fp->deleteIndex(index);
2070   return naNil();
2071 }
2072
2073 static naRef f_flightplan_clearPlan(naContext c, naRef me, int argc, naRef* args)
2074 {
2075   FlightPlan* fp = flightplanGhost(me);
2076   if (!fp) {
2077     naRuntimeError(c, "flightplan.clearPlan called on non-flightplan object");
2078   }
2079
2080   fp->clear();
2081   return naNil();
2082 }
2083
2084 static naRef f_flightplan_clearWPType(naContext c, naRef me, int argc, naRef* args)
2085 {
2086   FlightPlan* fp = flightplanGhost(me);
2087   if (!fp) {
2088     naRuntimeError(c, "flightplan.clearWPType called on non-flightplan object");
2089   }
2090
2091   if (argc < 1) {
2092     naRuntimeError(c, "insufficent args to flightplan.clearWPType");
2093   }
2094
2095   WayptFlag flag = wayptFlagFromString(naStr_data(args[0]));
2096   fp->clearWayptsWithFlag(flag);
2097   return naNil();
2098 }
2099
2100 static naRef f_flightplan_clone(naContext c, naRef me, int argc, naRef* args)
2101 {
2102   FlightPlan* fp = flightplanGhost(me);
2103   if (!fp) {
2104     naRuntimeError(c, "flightplan.clone called on non-flightplan object");
2105   }
2106
2107   return ghostForFlightPlan(c, fp->clone());
2108 }
2109
2110 static naRef f_flightplan_pathGeod(naContext c, naRef me, int argc, naRef* args)
2111 {
2112   FlightPlan* fp = flightplanGhost(me);
2113   if (!fp) {
2114     naRuntimeError(c, "flightplan.clone called on non-flightplan object");
2115   }
2116
2117   if ((argc < 1) || !naIsNum(args[0])) {
2118     naRuntimeError(c, "bad argument to flightplan.pathGeod");
2119   }
2120
2121   if ((argc > 1) && !naIsNum(args[1])) {
2122     naRuntimeError(c, "bad argument to flightplan.pathGeod");
2123   }
2124
2125   int index = (int) args[0].num;
2126   double offset = (argc > 1) ? args[1].num : 0.0;
2127   naRef result = naNewHash(c);
2128   SGGeod g = fp->pointAlongRoute(index, offset);
2129   hashset(c, result, "lat", naNum(g.getLatitudeDeg()));
2130   hashset(c, result, "lon", naNum(g.getLongitudeDeg()));
2131   return result;
2132 }
2133
2134
2135 static naRef f_leg_setSpeed(naContext c, naRef me, int argc, naRef* args)
2136 {
2137   FlightPlan::Leg* leg = fpLegGhost(me);
2138   if (!leg) {
2139     naRuntimeError(c, "leg.setSpeed called on non-flightplan-leg object");
2140   }
2141
2142   if (argc < 2) {
2143     naRuntimeError(c, "bad arguments to leg.setSpeed");
2144   }
2145
2146   RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
2147   leg->setSpeed(rr, args[0].num);
2148   return naNil();
2149 }
2150
2151 static naRef f_leg_setAltitude(naContext c, naRef me, int argc, naRef* args)
2152 {
2153   FlightPlan::Leg* leg = fpLegGhost(me);
2154   if (!leg) {
2155     naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
2156   }
2157
2158   if (argc < 2) {
2159     naRuntimeError(c, "bad arguments to leg.setAltitude");
2160   }
2161
2162   RouteRestriction rr = routeRestrictionFromString(naStr_data(args[1]));
2163   leg->setAltitude(rr, args[0].num);
2164   return naNil();
2165 }
2166
2167 static naRef f_leg_path(naContext c, naRef me, int argc, naRef* args)
2168 {
2169   FlightPlan::Leg* leg = fpLegGhost(me);
2170   if (!leg) {
2171     naRuntimeError(c, "leg.setAltitude called on non-flightplan-leg object");
2172   }
2173
2174   RoutePath path(leg->owner());
2175   SGGeodVec gv(path.pathForIndex(leg->index()));
2176
2177   naRef result = naNewVector(c);
2178   BOOST_FOREACH(SGGeod p, gv) {
2179     // construct a geo.Coord!
2180     naRef coord = naNewHash(c);
2181     hashset(c, coord, "lat", naNum(p.getLatitudeDeg()));
2182     hashset(c, coord, "lon", naNum(p.getLongitudeDeg()));
2183     naVec_append(result, coord);
2184   }
2185
2186   return result;
2187 }
2188
2189 static naRef f_leg_courseAndDistanceFrom(naContext c, naRef me, int argc, naRef* args)
2190 {
2191     FlightPlan::Leg* leg = fpLegGhost(me);
2192     if (!leg) {
2193         naRuntimeError(c, "leg.courseAndDistanceFrom called on non-flightplan-leg object");
2194     }
2195
2196     SGGeod pos;
2197     geodFromArgs(args, 0, argc, pos);
2198
2199     double courseDeg;
2200     double distanceM;
2201     boost::tie(courseDeg, distanceM) = leg->waypoint()->courseAndDistanceFrom(pos);
2202
2203     naRef result = naNewVector(c);
2204     naVec_append(result, naNum(courseDeg));
2205     naVec_append(result, naNum(distanceM * SG_METER_TO_NM));
2206     return result;
2207 }
2208
2209 static naRef f_waypoint_navaid(naContext c, naRef me, int argc, naRef* args)
2210 {
2211   flightgear::Waypt* w = wayptGhost(me);
2212   if (!w) {
2213     naRuntimeError(c, "waypoint.navaid called on non-waypoint object");
2214   }
2215
2216   FGPositioned* pos = w->source();
2217   if (!pos) {
2218     return naNil();
2219   }
2220
2221   switch (pos->type()) {
2222   case FGPositioned::VOR:
2223   case FGPositioned::NDB:
2224   case FGPositioned::ILS:
2225   case FGPositioned::LOC:
2226   case FGPositioned::GS:
2227   case FGPositioned::DME:
2228   case FGPositioned::TACAN: {
2229     FGNavRecord* nav = (FGNavRecord*) pos;
2230     return ghostForNavaid(c, nav);
2231   }
2232
2233   default:
2234     return naNil();
2235   }
2236 }
2237
2238 static naRef f_waypoint_airport(naContext c, naRef me, int argc, naRef* args)
2239 {
2240   flightgear::Waypt* w = wayptGhost(me);
2241   if (!w) {
2242     naRuntimeError(c, "waypoint.navaid called on non-waypoint object");
2243   }
2244
2245   FGPositioned* pos = w->source();
2246   if (!pos || FGAirport::isAirportType(pos)) {
2247     return naNil();
2248   }
2249
2250   return ghostForAirport(c, (FGAirport*) pos);
2251 }
2252
2253 static naRef f_waypoint_runway(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 || (pos->type() != FGPositioned::RUNWAY)) {
2262     return naNil();
2263   }
2264
2265   return ghostForRunway(c, (FGRunway*) pos);
2266 }
2267
2268 static naRef f_procedure_transition(naContext c, naRef me, int argc, naRef* args)
2269 {
2270   Procedure* proc = procedureGhost(me);
2271   if (!proc) {
2272     naRuntimeError(c, "procedure.transition called on non-procedure object");
2273   }
2274
2275   if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
2276     naRuntimeError(c, "procedure.transition called on non-SID or -STAR");
2277   }
2278
2279   ArrivalDeparture* ad = (ArrivalDeparture*) proc;
2280   Transition* trans = ad->findTransitionByName(naStr_data(args[0]));
2281
2282   return ghostForProcedure(c, trans);
2283 }
2284
2285 static naRef f_procedure_route(naContext c, naRef me, int argc, naRef* args)
2286 {
2287   Procedure* proc = procedureGhost(me);
2288   if (!proc) {
2289     naRuntimeError(c, "procedure.route called on non-procedure object");
2290   }
2291
2292 // wrapping up tow different routines here - approach routing from the IAF
2293 // to the associated runway, and SID/STAR routing via an enroute transition
2294 // and possibly a runway transition or not.
2295   if (Approach::isApproach(proc->type())) {
2296     WayptRef iaf;
2297     if (argc > 0) {
2298       iaf = wayptFromArg(args[0]);
2299     }
2300
2301     WayptVec r;
2302     Approach* app = (Approach*) proc;
2303     if (!app->route(iaf, r)) {
2304       SG_LOG(SG_NASAL, SG_WARN, "procedure.route failed for Approach somehow");
2305       return naNil();
2306     }
2307
2308     return convertWayptVecToNasal(c, r);
2309   } else if ((proc->type() != PROCEDURE_SID) && (proc->type() != PROCEDURE_STAR)) {
2310     naRuntimeError(c, "procedure.route called on unsuitable procedure type");
2311   }
2312
2313   int argOffset = 0;
2314   FGRunway* rwy = runwayGhost(args[0]);
2315   if (rwy) ++argOffset;
2316
2317   ArrivalDeparture* ad = (ArrivalDeparture*) proc;
2318   Transition* trans = NULL;
2319   if (argOffset < argc) {
2320     trans = (Transition*) procedureGhost(args[argOffset]);
2321   }
2322
2323   // note either runway or trans may be NULL - that's ok
2324   WayptVec r;
2325   if (!ad->route(rwy, trans, r)) {
2326     SG_LOG(SG_NASAL, SG_WARN, "prcoedure.route failed for ArrvialDeparture somehow");
2327     return naNil();
2328   }
2329
2330   return convertWayptVecToNasal(c, r);
2331 }
2332
2333
2334 // Table of extension functions.  Terminate with zeros.
2335 static struct { const char* name; naCFunction func; } funcs[] = {
2336   { "carttogeod", f_carttogeod },
2337   { "geodtocart", f_geodtocart },
2338   { "geodinfo", f_geodinfo },
2339   { "airportinfo", f_airportinfo },
2340   { "findAirportsWithinRange", f_findAirportsWithinRange },
2341   { "findAirportsByICAO", f_findAirportsByICAO },
2342   { "navinfo", f_navinfo },
2343   { "findNavaidsWithinRange", f_findNavaidsWithinRange },
2344   { "findNavaidByFrequency", f_findNavaidByFrequency },
2345   { "findNavaidsByFrequency", f_findNavaidsByFrequency },
2346   { "findNavaidsByID", f_findNavaidsByIdent },
2347   { "findFixesByID", f_findFixesByIdent },
2348   { "flightplan", f_route },
2349   { "registerFlightPlanDelegate", f_registerFPDelegate },
2350   { "createWP", f_createWP },
2351   { "createWPFrom", f_createWPFrom },
2352   { "airwaysRoute", f_airwaySearch },
2353   { "magvar", f_magvar },
2354   { "courseAndDistance", f_courseAndDistance },
2355   { "greatCircleMove", f_greatCircleMove },
2356   { "tileIndex", f_tileIndex },
2357   { "tilePath", f_tilePath },
2358   { 0, 0 }
2359 };
2360
2361
2362 naRef initNasalPositioned(naRef globals, naContext c, naRef gcSave)
2363 {
2364     airportPrototype = naNewHash(c);
2365     hashset(c, gcSave, "airportProto", airportPrototype);
2366
2367     hashset(c, airportPrototype, "runway", naNewFunc(c, naNewCCode(c, f_airport_runway)));
2368     hashset(c, airportPrototype, "runwaysWithoutReciprocals", naNewFunc(c, naNewCCode(c, f_airport_runwaysWithoutReciprocals)));
2369     hashset(c, airportPrototype, "helipad", naNewFunc(c, naNewCCode(c, f_airport_runway)));
2370     hashset(c, airportPrototype, "tower", naNewFunc(c, naNewCCode(c, f_airport_tower)));
2371     hashset(c, airportPrototype, "comms", naNewFunc(c, naNewCCode(c, f_airport_comms)));
2372     hashset(c, airportPrototype, "sids", naNewFunc(c, naNewCCode(c, f_airport_sids)));
2373     hashset(c, airportPrototype, "stars", naNewFunc(c, naNewCCode(c, f_airport_stars)));
2374     hashset(c, airportPrototype, "getApproachList", naNewFunc(c, naNewCCode(c, f_airport_approaches)));
2375     hashset(c, airportPrototype, "parking", naNewFunc(c, naNewCCode(c, f_airport_parking)));
2376     hashset(c, airportPrototype, "getSid", naNewFunc(c, naNewCCode(c, f_airport_getSid)));
2377     hashset(c, airportPrototype, "getStar", naNewFunc(c, naNewCCode(c, f_airport_getStar)));
2378     hashset(c, airportPrototype, "getIAP", naNewFunc(c, naNewCCode(c, f_airport_getApproach)));
2379     hashset(c, airportPrototype, "tostring", naNewFunc(c, naNewCCode(c, f_airport_toString)));
2380
2381     flightplanPrototype = naNewHash(c);
2382     hashset(c, gcSave, "flightplanProto", flightplanPrototype);
2383
2384     hashset(c, flightplanPrototype, "getWP", naNewFunc(c, naNewCCode(c, f_flightplan_getWP)));
2385     hashset(c, flightplanPrototype, "currentWP", naNewFunc(c, naNewCCode(c, f_flightplan_currentWP)));
2386     hashset(c, flightplanPrototype, "nextWP", naNewFunc(c, naNewCCode(c, f_flightplan_nextWP)));
2387     hashset(c, flightplanPrototype, "getPlanSize", naNewFunc(c, naNewCCode(c, f_flightplan_numWaypoints)));
2388     hashset(c, flightplanPrototype, "appendWP", naNewFunc(c, naNewCCode(c, f_flightplan_appendWP)));
2389     hashset(c, flightplanPrototype, "insertWP", naNewFunc(c, naNewCCode(c, f_flightplan_insertWP)));
2390     hashset(c, flightplanPrototype, "deleteWP", naNewFunc(c, naNewCCode(c, f_flightplan_deleteWP)));
2391     hashset(c, flightplanPrototype, "insertWPAfter", naNewFunc(c, naNewCCode(c, f_flightplan_insertWPAfter)));
2392     hashset(c, flightplanPrototype, "insertWaypoints", naNewFunc(c, naNewCCode(c, f_flightplan_insertWaypoints)));
2393     hashset(c, flightplanPrototype, "cleanPlan", naNewFunc(c, naNewCCode(c, f_flightplan_clearPlan)));
2394     hashset(c, flightplanPrototype, "clearWPType", naNewFunc(c, naNewCCode(c, f_flightplan_clearWPType)));
2395     hashset(c, flightplanPrototype, "clone", naNewFunc(c, naNewCCode(c, f_flightplan_clone)));
2396     hashset(c, flightplanPrototype, "pathGeod", naNewFunc(c, naNewCCode(c, f_flightplan_pathGeod)));
2397
2398     waypointPrototype = naNewHash(c);
2399     hashset(c, gcSave, "wayptProto", waypointPrototype);
2400
2401     hashset(c, waypointPrototype, "navaid", naNewFunc(c, naNewCCode(c, f_waypoint_navaid)));
2402     hashset(c, waypointPrototype, "runway", naNewFunc(c, naNewCCode(c, f_waypoint_runway)));
2403     hashset(c, waypointPrototype, "airport", naNewFunc(c, naNewCCode(c, f_waypoint_airport)));
2404
2405     procedurePrototype = naNewHash(c);
2406     hashset(c, gcSave, "procedureProto", procedurePrototype);
2407     hashset(c, procedurePrototype, "transition", naNewFunc(c, naNewCCode(c, f_procedure_transition)));
2408     hashset(c, procedurePrototype, "route", naNewFunc(c, naNewCCode(c, f_procedure_route)));
2409
2410     fpLegPrototype = naNewHash(c);
2411     hashset(c, gcSave, "fpLegProto", fpLegPrototype);
2412     hashset(c, fpLegPrototype, "setSpeed", naNewFunc(c, naNewCCode(c, f_leg_setSpeed)));
2413     hashset(c, fpLegPrototype, "setAltitude", naNewFunc(c, naNewCCode(c, f_leg_setAltitude)));
2414     hashset(c, fpLegPrototype, "path", naNewFunc(c, naNewCCode(c, f_leg_path)));
2415     hashset(c, fpLegPrototype, "courseAndDistanceFrom", naNewFunc(c, naNewCCode(c, f_leg_courseAndDistanceFrom)));
2416
2417     for(int i=0; funcs[i].name; i++) {
2418       hashset(c, globals, funcs[i].name,
2419       naNewFunc(c, naNewCCode(c, funcs[i].func)));
2420     }
2421
2422   return naNil();
2423 }
2424
2425 void postinitNasalPositioned(naRef globals, naContext c)
2426 {
2427   naRef geoModule = naHash_cget(globals, (char*) "geo");
2428   if (naIsNil(geoModule)) {
2429     SG_LOG(SG_GENERAL, SG_WARN, "postinitNasalPositioned: geo.nas not loaded");
2430     return;
2431   }
2432
2433   geoCoordClass = naHash_cget(geoModule, (char*) "Coord");
2434 }
2435
2436