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