]> git.mxchange.org Git - simgear.git/blob - simgear/environment/metar.cxx
warnings--
[simgear.git] / simgear / environment / metar.cxx
1 // metar interface class
2 //
3 // Written by Melchior FRANZ, started December 2003.
4 //
5 // Copyright (C) 2003  Melchior FRANZ - mfranz@aon.at
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 // $Id$
22
23 /**
24  * @file metar.cxx
25  * Interface for encoded Meteorological Aerodrome Reports (METAR).
26  */
27 #ifdef HAVE_CONFIG_H
28 #  include <simgear_config.h>
29 #endif
30
31 #include <string>
32 #include <time.h>
33
34 #include <simgear/io/sg_socket.hxx>
35 #include <simgear/debug/logstream.hxx>
36 #include <simgear/structure/exception.hxx>
37
38 #include "metar.hxx"
39
40 #define NaN SGMetarNaN
41
42 /**
43  * The constructor takes a Metar string, or a four-letter ICAO code. In the
44  * latter case the metar string is downloaded from
45  * http://weather.noaa.gov/pub/data/observations/metar/stations/.
46  * The constructor throws sg_io_exceptions on failure. The "METAR"
47  * keyword has no effect (apart from incrementing the group counter
48  * @a grpcount) and can be left away. A keyword "SPECI" is
49  * likewise accepted.
50  *
51  * @param m     ICAO station id or metar string
52  * @param proxy proxy host (optional; default: "")
53  * @param port  proxy port (optional; default: "80")
54  * @param auth  proxy authorization information (optional; default: "")
55  *
56  * @par Examples:
57  * @code
58  * SGMetar *m = new SGMetar("METAR KSFO 061656Z 19004KT 9SM SCT100 OVC200 08/03 A3013");
59  * double t = m->getTemperature_F();
60  * delete m;
61  *
62  * SGMetar n("KSFO", "proxy.provider.foo", "3128", "proxy-password");
63  * double d = n.getDewpoint_C();
64  * @endcode
65  */
66 SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
67                 const string& auth, const time_t time) :
68         _grpcount(0),
69         _x_proxy(false),
70         _year(-1),
71         _month(-1),
72         _day(-1),
73         _hour(-1),
74         _minute(-1),
75         _report_type(-1),
76         _wind_dir(-1),
77         _wind_speed(NaN),
78         _gust_speed(NaN),
79         _wind_range_from(-1),
80         _wind_range_to(-1),
81         _temp(NaN),
82         _dewp(NaN),
83         _pressure(NaN),
84         _rain(false),
85         _hail(false),
86         _snow(false),
87         _cavok(false)
88 {
89         if (m.length() == 4 && isalnum(m[0]) && isalnum(m[1]) && isalnum(m[2]) && isalnum(m[3])) {
90                 for (int i = 0; i < 4; i++)
91                         _icao[i] = toupper(m[i]);
92                 _icao[4] = '\0';
93                 _data = loadData(_icao, proxy, port, auth, time);
94         } else {
95                 _data = new char[m.length() + 2];       // make room for " \0"
96                 strcpy(_data, m.c_str());
97                 _url = _data;
98         }
99         normalizeData();
100
101         _m = _data;
102         _icao[0] = '\0';
103
104         // NOAA preample
105         if (!scanPreambleDate())
106                 useCurrentDate();
107         scanPreambleTime();
108
109         // METAR header
110         scanType();
111         if (!scanId() || !scanDate()) {
112                 delete[] _data;
113                 throw sg_io_exception("metar data bogus ", sg_location(_url));
114         }
115         scanModifier();
116
117         // base set
118         scanWind();
119         scanVariability();
120         while (scanVisibility()) ;
121         while (scanRwyVisRange()) ;
122         while (scanWeather()) ;
123         while (scanSkyCondition()) ;
124         scanTemperature();
125         scanPressure();
126         while (scanSkyCondition()) ;
127         while (scanRunwayReport()) ;
128         scanWindShear();
129
130         // appendix
131         while (scanColorState()) ;
132         scanTrendForecast();
133         while (scanRunwayReport()) ;
134         scanRemainder();
135         scanRemark();
136
137         if (_grpcount < 4) {
138                 delete[] _data;
139                 throw sg_io_exception("metar data incomplete ", sg_location(_url));
140         }
141
142         _url = "";
143 }
144
145
146 /**
147   * Clears lists and maps to discourage access after destruction.
148   */
149 SGMetar::~SGMetar()
150 {
151         _clouds.clear();
152         _runways.clear();
153         _weather.clear();
154         delete[] _data;
155 }
156
157
158 void SGMetar::useCurrentDate()
159 {
160         struct tm now;
161         time_t now_sec = time(0);
162 #if defined( _MSC_VER ) || defined ( __MINGW32__ )
163         now = *gmtime(&now_sec);
164 #else
165         gmtime_r(&now_sec, &now);
166 #endif
167         _year = now.tm_year + 1900;
168         _month = now.tm_mon + 1;
169 }
170
171
172 /**
173   * If called with "KSFO" loads data from
174   * @code
175   * http://weather.noaa.gov/pub/data/observations/metar/stations/KSFO.TXT.
176   * @endcode
177   * Throws sg_io_exception on failure. Gives up after waiting longer than 10 seconds.
178   *
179   * @param id four-letter ICAO Metar station code, e.g. "KSFO".
180   * @param proxy proxy host (optional; default: "")
181   * @param port  proxy port (optional; default: "80")
182   * @param auth  proxy authorization information (optional; default: "")
183   * @return pointer to Metar data string, allocated by new char[].
184   * @see rfc2068.txt for proxy spec ("Proxy-Authorization")
185   */
186 char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
187                 const string& auth, time_t time)
188 {
189         const int buflen = 512;
190         char buf[2 * buflen];
191
192         string host = proxy.empty() ? "weather.noaa.gov" : proxy;
193         string path = "/pub/data/observations/metar/stations/";
194
195         path += string(id) + ".TXT";
196         _url = "http://weather.noaa.gov" + path;
197
198         SGSocket *sock = new SGSocket(host, port.empty() ? "80" : port, "tcp");
199         sock->set_timeout(10000);
200         if (!sock->open(SG_IO_OUT)) {
201                 delete sock;
202                 throw sg_io_exception("cannot connect to ", sg_location(host));
203         }
204
205         string get = "GET ";
206         if (!proxy.empty())
207                 get += "http://weather.noaa.gov";
208
209         sprintf(buf, "%ld", time);
210         get += path + " HTTP/1.0\015\012X-Time: " + buf + "\015\012";
211
212         if (!auth.empty())
213                 get += "Proxy-Authorization: " + auth + "\015\012";
214
215         get += "\015\012";
216         sock->writestring(get.c_str());
217
218         int i;
219
220         // skip HTTP header
221         while ((i = sock->readline(buf, buflen))) {
222                 if (i <= 2 && isspace(buf[0]) && (!buf[1] || isspace(buf[1])))
223                         break;
224                 if (!strncmp(buf, "X-MetarProxy: ", 13))
225                         _x_proxy = true;
226         }
227         if (i) {
228                 i = sock->readline(buf, buflen);
229                 if (i)
230                         sock->readline(&buf[i], buflen);
231         }
232
233         sock->close();
234         delete sock;
235
236         char *b = buf;
237         scanBoundary(&b);
238         if (*b == '<')
239                 throw sg_io_exception("no metar data available from ", 
240                                 sg_location(_url));
241
242         char *metar = new char[strlen(b) + 2];  // make room for " \0"
243         strcpy(metar, b);
244         return metar;
245 }
246
247
248 /**
249   * Replace any number of subsequent spaces by just one space, and add
250   * a trailing space. This makes scanning for things like "ALL RWY" easier.
251   */
252 void SGMetar::normalizeData()
253 {
254         char *src, *dest;
255         for (src = dest = _data; (*dest++ = *src++); )
256                 while (*src == ' ' && src[1] == ' ')
257                         src++;
258         for (dest--; isspace(*--dest); ) ;
259         *++dest = ' ';
260         *++dest = '\0';
261 }
262
263
264 // \d\d\d\d/\d\d/\d\d
265 bool SGMetar::scanPreambleDate()
266 {
267         char *m = _m;
268         int year, month, day;
269         if (!scanNumber(&m, &year, 4))
270                 return false;
271         if (*m++ != '/')
272                 return false;
273         if (!scanNumber(&m, &month, 2))
274                 return false;
275         if (*m++ != '/')
276                 return false;
277         if (!scanNumber(&m, &day, 2))
278                 return false;
279         if (!scanBoundary(&m))
280                 return false;
281         _year = year;
282         _month = month;
283         _day = day;
284         _m = m;
285         return true;
286 }
287
288
289 // \d\d:\d\d
290 bool SGMetar::scanPreambleTime()
291 {
292         char *m = _m;
293         int hour, minute;
294         if (!scanNumber(&m, &hour, 2))
295                 return false;
296         if (*m++ != ':')
297                 return false;
298         if (!scanNumber(&m, &minute, 2))
299                 return false;
300         if (!scanBoundary(&m))
301                 return false;
302         _hour = hour;
303         _minute = minute;
304         _m = m;
305         return true;
306 }
307
308
309 // (METAR|SPECI)
310 bool SGMetar::scanType()
311 {
312         if (strncmp(_m, "METAR ", 6) && strncmp(_m, "SPECI ", 6))
313                 return false;
314         _m += 6;
315         _grpcount++;
316         return true;
317 }
318
319
320 // [A-Z]{4}
321 bool SGMetar::scanId()
322 {
323         char *m = _m;
324         for (int i = 0; i < 4; m++, i++)
325                 if (!(isalpha(*m) || isdigit(*m)))
326                         return false;
327         if (!scanBoundary(&m))
328                 return false;
329         strncpy(_icao, _m, 4);
330         _icao[4] = '\0';
331         _m = m;
332         _grpcount++;
333         return true;
334 }
335
336
337 // \d{6}Z
338 bool SGMetar::scanDate()
339 {
340         char *m = _m;
341         int day, hour, minute;
342         if (!scanNumber(&m, &day, 2))
343                 return false;
344         if (!scanNumber(&m, &hour, 2))
345                 return false;
346         if (!scanNumber(&m, &minute, 2))
347                 return false;
348         if (*m++ != 'Z')
349                 return false;
350         if (!scanBoundary(&m))
351                 return false;
352         _day = day;
353         _hour = hour;
354         _minute = minute;
355         _m = m;
356         _grpcount++;
357         return true;
358 }
359
360
361 // (NIL|AUTO|COR|RTD)
362 bool SGMetar::scanModifier()
363 {
364         char *m = _m;
365         int type;
366         if (!strncmp(m, "NIL", 3)) {
367                 _m += strlen(_m);
368                 return true;
369         }
370         if (!strncmp(m, "AUTO", 4))                     // automatically generated
371                 m += 4, type = AUTO;
372         else if (!strncmp(m, "COR", 3))                 // manually corrected
373                 m += 3, type = COR;
374         else if (!strncmp(m, "RTD", 3))                 // routine delayed
375                 m += 3, type = RTD;
376         else
377                 return false;
378         if (!scanBoundary(&m))
379                 return false;
380         _report_type = type;
381         _m = m;
382         _grpcount++;
383         return true;
384 }
385
386
387 // (\d{3}|VRB)\d{1,3}(G\d{2,3})?(KT|KMH|MPS)
388 bool SGMetar::scanWind()
389 {
390         char *m = _m;
391         int dir;
392         if (!strncmp(m, "VRB", 3))
393                 m += 3, dir = -1;
394         else if (!scanNumber(&m, &dir, 3))
395                 return false;
396
397         int i;
398         if (!scanNumber(&m, &i, 2, 3))
399                 return false;
400         double speed = i;
401
402         double gust = NaN;
403         if (*m == 'G') {
404                 m++;
405                 if (!scanNumber(&m, &i, 2, 3))
406                         return false;
407                 gust = i;
408         }
409         double factor;
410         if (!strncmp(m, "KT", 2))
411                 m += 2, factor = SG_KT_TO_MPS;
412         else if (!strncmp(m, "KMH", 3))
413                 m += 3, factor = SG_KMH_TO_MPS;
414         else if (!strncmp(m, "KPH", 3))         // ??
415                 m += 3, factor = SG_KMH_TO_MPS;
416         else if (!strncmp(m, "MPS", 3))
417                 m += 3, factor = 1.0;
418         else
419                 return false;
420         if (!scanBoundary(&m))
421                 return false;
422         _m = m;
423         _wind_dir = dir;
424         _wind_speed = speed * factor;
425         if (gust != NaN)
426                 _gust_speed = gust * factor;
427         _grpcount++;
428         return true;
429 }
430
431
432 // \d{3}V\d{3}
433 bool SGMetar::scanVariability()
434 {
435         char *m = _m;
436         int from, to;
437         if (!scanNumber(&m, &from, 3))
438                 return false;
439         if (*m++ != 'V')
440                 return false;
441         if (!scanNumber(&m, &to, 3))
442                 return false;
443         if (!scanBoundary(&m))
444                 return false;
445         _m = m;
446         _wind_range_from = from;
447         _wind_range_to = to;
448         _grpcount++;
449         return true;
450 }
451
452
453 bool SGMetar::scanVisibility()
454 // TODO: if only directed vis are given, do still set min/max
455 {
456         if (!strncmp(_m, "//// ", 5)) {         // spec compliant?
457                 _m += 5;
458                 _grpcount++;
459                 return true;
460         }
461
462         char *m = _m;
463         double distance;
464         int i, dir = -1;
465         int modifier = SGMetarVisibility::EQUALS;
466 // \d{4}(N|NE|E|SE|S|SW|W|NW)?
467         if (scanNumber(&m, &i, 4)) {
468                 if (*m == 'E')
469                         m++, dir = 90;
470                 else if (*m == 'W')
471                         m++, dir = 270;
472                 else if (*m == 'N') {
473                         m++;
474                         if (*m == 'E')
475                                 m++, dir = 45;
476                         else if (*m == 'W')
477                                 m++, dir = 315;
478                         else
479                                 dir = 0;
480                 } else if (*m == 'S') {
481                         m++;
482                         if (*m == 'E')
483                                 m++, dir = 135;
484                         else if (*m == 'W')
485                                 m++, dir = 225;
486                         else
487                                 dir = 180;
488                 }
489                 if (i == 0)
490                         i = 50, modifier = SGMetarVisibility::LESS_THAN;
491                 else if (i == 9999)
492                         i++, modifier = SGMetarVisibility::GREATER_THAN;
493                 distance = i;
494         } else {
495 // M?(\d{1,2}|\d{1,2}/\d{1,2}|\d{1,2} \d{1,2}/\d{1,2})(SM|KM)
496                 if (*m == 'M')
497                         m++, modifier = SGMetarVisibility::LESS_THAN;
498
499                 if (!scanNumber(&m, &i, 1, 2))
500                         return false;
501                 distance = i;
502
503                 if (*m == '/') {
504                         m++;
505                         if (!scanNumber(&m, &i, 1, 2))
506                                 return false;
507                         distance /= i;
508                 } else if (*m == ' ') {
509                         m++;
510                         int denom;
511                         if (!scanNumber(&m, &i, 1, 2))
512                                 return false;
513                         if (*m++ != '/')
514                                 return false;
515                         if (!scanNumber(&m, &denom, 1, 2))
516                                 return false;
517                         distance += (double)i / denom;
518                 }
519
520                 if (!strncmp(m, "SM", 2))
521                         distance *= SG_SM_TO_METER, m += 2;
522                 else if (!strncmp(m, "KM", 2))
523                         distance *= 1000, m += 2;
524                 else
525                         return false;
526         }
527         if (!scanBoundary(&m))
528                 return false;
529
530         SGMetarVisibility *v;
531         if (dir != -1)
532                 v = &_dir_visibility[dir / 45];
533         else if (_min_visibility._distance == NaN)
534                 v = &_min_visibility;
535         else
536                 v = &_max_visibility;
537
538         v->_distance = distance;
539         v->_modifier = modifier;
540         v->_direction = dir;
541         _m = m;
542         _grpcount++;
543         return true;
544 }
545
546
547 // R\d\d[LCR]?/([PM]?\d{4}V)?[PM]?\d{4}(FT)?[DNU]?
548 bool SGMetar::scanRwyVisRange()
549 {
550         char *m = _m;
551         int i;
552         SGMetarRunway r;
553         if (*m++ != 'R')
554                 return false;
555         if (!scanNumber(&m, &i, 2))
556                 return false;
557         if (*m == 'L' || *m == 'C' || *m == 'R')
558                 m++;
559
560         char id[4];
561         strncpy(id, _m + 1, i = m - _m - 1);
562         id[i] = '\0';
563
564         if (*m++ != '/')
565                 return false;
566
567         int from, to;
568         if (*m == 'P')
569                 m++, r._min_visibility._modifier = SGMetarVisibility::GREATER_THAN;
570         else if (*m == 'M')
571                 m++, r._min_visibility._modifier = SGMetarVisibility::LESS_THAN;
572         if (!scanNumber(&m, &from, 4))
573                 return false;
574         if (*m == 'V') {
575                 m++;
576                 if (*m == 'P')
577                         m++, r._max_visibility._modifier = SGMetarVisibility::GREATER_THAN;
578                 else if (*m == 'M')
579                         m++, r._max_visibility._modifier = SGMetarVisibility::LESS_THAN;
580                 if (!scanNumber(&m, &to, 4))
581                         return false;
582         } else
583                 to = from;
584
585         if (!strncmp(m, "FT", 2)) {
586                 from = int(from * SG_FEET_TO_METER);
587                 to = int(to * SG_FEET_TO_METER);
588                 m += 2;
589         }
590         r._min_visibility._distance = from;
591         r._max_visibility._distance = to;
592
593         if (*m == '/')                                  // this is not in the spec!
594                 *m++;
595         if (*m == 'D')
596                 m++, r._min_visibility._tendency = SGMetarVisibility::DECREASING;
597         else if (*m == 'N')
598                 m++, r._min_visibility._tendency = SGMetarVisibility::STABLE;
599         else if (*m == 'U')
600                 m++, r._min_visibility._tendency = SGMetarVisibility::INCREASING;
601
602         if (!scanBoundary(&m))
603                 return false;
604         _m = m;
605
606         _runways[id]._min_visibility = r._min_visibility;
607         _runways[id]._max_visibility = r._max_visibility;
608         _grpcount++;
609         return true;
610 }
611
612
613 static const struct Token special[] = {
614         { "NSW",  "no significant weather" },
615         { "VCSH", "showers in the vicinity" },
616         { "VCTS", "thunderstorm in the vicinity" },
617         { 0, 0 }
618 };
619
620
621 static const struct Token description[] = {
622         { "SH", "showers of" },
623         { "TS", "thunderstorm with" },
624         { "BC", "patches of" },
625         { "BL", "blowing" },
626         { "DR", "low drifting" },
627         { "FZ", "freezing" },
628         { "MI", "shallow" },
629         { "PR", "partial" },
630         { 0, 0 }
631 };
632
633
634 static const struct Token phenomenon[] = {
635         { "DZ",   "drizzle" },
636         { "GR",   "hail" },
637         { "GS",   "small hail and/or snow pellets" },
638         { "IC",   "ice crystals" },
639         { "PE",   "ice pellets" },
640         { "RA",   "rain" },
641         { "SG",   "snow grains" },
642         { "SN",   "snow" },
643         { "UP",   "unknown precipitation" },
644         { "BR",   "mist" },
645         { "DU",   "widespread dust" },
646         { "FG",   "fog" },
647         { "FGBR", "fog bank" },
648         { "FU",   "smoke" },
649         { "HZ",   "haze" },
650         { "PY",   "spray" },
651         { "SA",   "sand" },
652         { "VA",   "volcanic ash" },
653         { "DS",   "duststorm" },
654         { "FC",   "funnel cloud/tornado waterspout" },
655         { "PO",   "well-developed dust/sand whirls" },
656         { "SQ",   "squalls" },
657         { "SS",   "sandstorm" },
658         { "UP",   "unknown" },  // ... due to failed automatic acquisition
659         { 0, 0 }
660 };
661
662
663 // (+|-|VC)?(NSW|MI|PR|BC|DR|BL|SH|TS|FZ)?((DZ|RA|SN|SG|IC|PE|GR|GS|UP){0,3})(BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS){0,3}
664 bool SGMetar::scanWeather()
665 {
666         char *m = _m;
667         string weather;
668         const struct Token *a;
669         if ((a = scanToken(&m, special))) {
670                 if (!scanBoundary(&m))
671                         return false;
672                 _weather.push_back(a->text);
673                 _m = m;
674                 return true;
675         }
676
677         string pre, post;
678         int intensity = 0;
679         if (*m == '-')
680                 m++, pre = "light ", intensity = 1;
681         else if (*m == '+')
682                 m++, pre = "heavy ", intensity = 3;
683         else if (!strncmp(m, "VC", 2))
684                 m += 2, post = "in the vicinity ";
685         else
686                 pre = "moderate ", intensity = 2;
687
688         int i;
689         for (i = 0; i < 3; i++) {
690                 if (!(a = scanToken(&m, description)))
691                         break;
692                 weather += string(a->text) + " ";
693         }
694         for (i = 0; i < 3; i++) {
695                 if (!(a = scanToken(&m, phenomenon)))
696                         break;
697                 weather += string(a->text) + " ";
698                 if (!strcmp(a->id, "RA"))
699                         _rain = intensity;
700                 else if (!strcmp(a->id, "HA"))
701                         _hail = intensity;
702                 else if (!strcmp(a->id, "SN"))
703                         _snow = intensity;
704         }
705         if (!weather.length())
706                 return false;
707         if (!scanBoundary(&m))
708                 return false;
709         _m = m;
710         weather = pre + weather + post;
711         weather.erase(weather.length() - 1);
712         _weather.push_back(weather);
713         _grpcount++;
714         return true;
715 }
716
717
718 static const struct Token cloud_types[] = {
719         { "AC",    "altocumulus" },
720         { "ACC",   "altocumulus castellanus" },
721         { "ACSL",  "altocumulus standing lenticular" },
722         { "AS",    "altostratus" },
723         { "CB",    "cumulonimbus" },
724         { "CBMAM", "cumulonimbus mammatus" },
725         { "CC",    "cirrocumulus" },
726         { "CCSL",  "cirrocumulus standing lenticular" },
727         { "CI",    "cirrus" },
728         { "CS",    "cirrostratus" },
729         { "CU",    "cumulus" },
730         { "CUFRA", "cumulus fractus" },
731         { "NS",    "nimbostratus" },
732         { "SAC",   "stratoaltocumulus" },               // guessed
733         { "SC",    "stratocumulus" },
734         { "SCSL",  "stratocumulus standing lenticular" },
735         { "ST",    "stratus" },
736         { "STFRA", "stratus fractus" },
737         { "TCU",   "towering cumulus" },
738         { 0, 0 }
739 };
740
741
742 // (FEW|SCT|BKN|OVC|SKC|CLR|CAVOK|VV)([0-9]{3}|///)?[:cloud_type:]?
743 bool SGMetar::scanSkyCondition()
744 {
745         char *m = _m;
746         int i;
747         SGMetarCloud cl;
748
749         if (!strncmp(m, "//////", 6)) {
750                 m += 6;
751                 if (!scanBoundary(&m))
752                         return false;
753                 _m = m;
754                 return true;
755         }
756
757         if (!strncmp(m, "CLR", i = 3)                           // clear
758                         || !strncmp(m, "SKC", i = 3)            // sky clear
759                         || !strncmp(m, "NSC", i = 3)            // no significant clouds
760                         || !strncmp(m, "CAVOK", i = 5)) {       // ceiling and visibility OK (implies 9999)
761                 m += i;
762                 if (!scanBoundary(&m))
763                         return false;
764
765                 if (i == 3) {
766                         cl._coverage = 0;
767                         _clouds.push_back(cl);
768                 } else {
769                         _cavok = true;
770                 }
771                 _m = m;
772                 return true;
773         }
774
775         if (!strncmp(m, "VV", i = 2))                           // vertical visibility
776                 ;
777         else if (!strncmp(m, "FEW", i = 3))
778                 cl._coverage = 1;
779         else if (!strncmp(m, "SCT", i = 3))
780                 cl._coverage = 2;
781         else if (!strncmp(m, "BKN", i = 3))
782                 cl._coverage = 3;
783         else if (!strncmp(m, "OVC", i = 3))
784                 cl._coverage = 4;
785         else
786                 return false;
787         m += i;
788
789         if (!strncmp(m, "///", 3))      // vis not measurable (e.g. because of heavy snowing)
790                 m += 3, i = -1;
791         else if (scanBoundary(&m)) {
792                 _m = m;
793                 return true;                            // ignore single OVC/BKN/...
794         } else if (!scanNumber(&m, &i, 3))
795                 i = -1;
796
797         if (cl._coverage == -1) {
798                 if (!scanBoundary(&m))
799                         return false;
800                 if (i == -1)                    // 'VV///'
801                         _vert_visibility._modifier = SGMetarVisibility::NOGO;
802                 else
803                         _vert_visibility._distance = i * 100 * SG_FEET_TO_METER;
804                 _m = m;
805                 return true;
806         }
807
808         if (i != -1)
809                 cl._altitude = i * 100 * SG_FEET_TO_METER;
810
811         const struct Token *a;
812         if ((a = scanToken(&m, cloud_types))) {
813                 cl._type = a->id;
814                 cl._type_long = a->text;
815         }
816         if (!scanBoundary(&m))
817                 return false;
818         _clouds.push_back(cl);
819         _m = m;
820         _grpcount++;
821         return true;
822 }
823
824
825 // M?[0-9]{2}/(M?[0-9]{2})?            (spec)
826 // (M?[0-9]{2}|XX)/(M?[0-9]{2}|XX)?    (Namibia)
827 bool SGMetar::scanTemperature()
828 {
829         char *m = _m;
830         int sign = 1, temp, dew;
831         if (!strncmp(m, "XX/XX", 5)) {          // not spec compliant!
832                 _m += 5;
833                 return scanBoundary(&_m);
834         }
835
836         if (*m == 'M')
837                 m++, sign = -1;
838         if (!scanNumber(&m, &temp, 2))
839                 return false;
840         temp *= sign;
841
842         if (*m++ != '/')
843                 return false;
844         if (!scanBoundary(&m)) {
845                 if (!strncmp(m, "XX", 2))       // not spec compliant!
846                         m += 2, sign = 0, dew = temp;
847                 else {
848                         sign = 1;
849                         if (*m == 'M')
850                                 m++, sign = -1;
851                         if (!scanNumber(&m, &dew, 2))
852                                 return false;
853                 }
854                 if (!scanBoundary(&m))
855                         return false;
856                 if (sign)
857                         _dewp = sign * dew;
858         }
859         _temp = temp;
860         _m = m;
861         _grpcount++;
862         return true;
863 }
864
865
866 double SGMetar::getRelHumidity() const
867 {
868         if (_temp == NaN || _dewp == NaN)
869                 return NaN;
870         double dewp = pow(10.0, 7.5 * _dewp / (237.7 + _dewp));
871         double temp = pow(10.0, 7.5 * _temp / (237.7 + _temp));
872         return dewp * 100 / temp;
873 }
874
875
876 // [AQ]\d{4}             (spec)
877 // [AQ]\d{2}(\d{2}|//)   (Namibia)
878 bool SGMetar::scanPressure()
879 {
880         char *m = _m;
881         double factor;
882         int press, i;
883
884         if (*m == 'A')
885                 factor = SG_INHG_TO_PA / 100;
886         else if (*m == 'Q')
887                 factor = 100;
888         else
889                 return false;
890         m++;
891         if (!scanNumber(&m, &press, 2))
892                 return false;
893         press *= 100;
894         if (!strncmp(m, "//", 2))       // not spec compliant!
895                 m += 2;
896         else if (scanNumber(&m, &i, 2))
897                 press += i;
898         else
899                 return false;
900         if (!scanBoundary(&m))
901                 return false;
902         _pressure = press * factor;
903         _m = m;
904         _grpcount++;
905         return true;
906 }
907
908
909 static const char *runway_deposit[] = {
910         "clear and dry",
911         "damp",
912         "wet or puddles",
913         "frost",
914         "dry snow",
915         "wet snow",
916         "slush",
917         "ice",
918         "compacted snow",
919         "frozen ridges"
920 };
921
922
923 static const char *runway_deposit_extent[] = {
924         0, "1-10%", "11-25%", 0, 0, "26-50%", 0, 0, 0, "51-100%"
925 };
926
927
928 static const char *runway_friction[] = {
929         0,
930         "poor braking action",
931         "poor/medium braking action",
932         "medium braking action",
933         "medium/good braking action",
934         "good braking action",
935         0, 0, 0,
936         "friction: unreliable measurement"
937 };
938
939
940 // \d\d(CLRD|[\d/]{4})(\d\d|//)
941 bool SGMetar::scanRunwayReport()
942 {
943         char *m = _m;
944         int i;
945         char id[4];
946         SGMetarRunway r;
947
948         if (!scanNumber(&m, &i, 2))
949                 return false;
950         if (i == 88)
951                 strcpy(id, "ALL");
952         else if (i == 99)
953                 strcpy(id, "REP");              // repetition of previous report
954         else if (i >= 50) {
955                 i -= 50;
956                 id[0] = i / 10 + '0', id[1] = i % 10 + '0', id[2] = 'R', id[3] = '\0';
957         } else
958                 id[0] = i / 10 + '0', id[1] = i % 10 + '0', id[2] = '\0';
959
960         if (!strncmp(m, "CLRD", 4)) {
961                 m += 4;                                                 // runway cleared
962                 r._deposit_string = "cleared";
963         } else {
964                 if (scanNumber(&m, &i, 1)) {
965                         r._deposit = i;
966                         r._deposit_string = runway_deposit[i];
967                 } else if (*m == '/')
968                         m++;
969                 else
970                         return false;
971
972                 if (*m == '1' || *m == '2' || *m == '5' || *m == '9') { // extent of deposit
973                         r._extent = *m - '0';
974                         r._extent_string = runway_deposit_extent[*m - '0'];
975                 } else if (*m != '/')
976                         return false;
977
978                 m++;
979                 i = -1;
980                 if (!strncmp(m, "//", 2))
981                         m += 2;
982                 else if (!scanNumber(&m, &i, 2))
983                         return false;
984
985                 if (i == 0)
986                         r._depth = 0.0005;                              // < 1 mm deep (let's say 0.5 :-)
987                 else if (i > 0 && i <= 90)
988                         r._depth = i / 1000.0;                          // i mm deep
989                 else if (i >= 92 && i <= 98)
990                         r._depth = (i - 90) / 20.0;
991                 else if (i == 99)
992                         r._comment = "runway not in use";
993                 else if (i == -1)                                       // no depth given ("//")
994                         ;
995                 else
996                         return false;
997         }
998         i = -1;
999         if (m[0] == '/' && m[1] == '/')
1000                 m += 2;
1001         else if (!scanNumber(&m, &i, 2))
1002                 return false;
1003         if (i >= 1 && i < 90) {
1004                 r._friction = i / 100.0;
1005         } else if ((i >= 91 && i <= 95) || i == 99) {
1006                 r._friction_string = runway_friction[i - 90];
1007         }
1008         if (!scanBoundary(&m))
1009                 return false;
1010
1011         _runways[id]._deposit = r._deposit;
1012         _runways[id]._deposit_string = r._deposit_string;
1013         _runways[id]._extent = r._extent;
1014         _runways[id]._extent_string = r._extent_string;
1015         _runways[id]._depth = r._depth;
1016         _runways[id]._friction = r._friction;
1017         _runways[id]._friction_string = r._friction_string;
1018         _runways[id]._comment = r._comment;
1019         _m = m;
1020         _grpcount++;
1021         return true;
1022 }
1023
1024
1025 // WS (ALL RWYS?|RWY ?\d\d[LCR]?)?
1026 bool SGMetar::scanWindShear()
1027 {
1028         char *m = _m;
1029         if (strncmp(m, "WS", 2))
1030                 return false;
1031         m += 2;
1032         if (!scanBoundary(&m))
1033                 return false;
1034
1035         if (!strncmp(m, "ALL", 3)) {
1036                 m += 3;
1037                 if (!scanBoundary(&m))
1038                         return false;
1039                 if (strncmp(m, "RWY", 3))
1040                         return false;
1041                 m += 3;
1042                 if (*m == 'S')
1043                         m++;
1044                 if (!scanBoundary(&m))
1045                         return false;
1046                 _runways["ALL"]._wind_shear = true;
1047                 _m = m;
1048                 return true;
1049         }
1050
1051         char id[4], *mm;
1052         int i, cnt;
1053         for (cnt = 0;; cnt++) {                 // ??
1054                 if (strncmp(m, "RWY", 3))
1055                         break;
1056                 m += 3;
1057                 scanBoundary(&m);
1058                 mm = m;
1059                 if (!scanNumber(&m, &i, 2))
1060                         return false;
1061                 if (*m == 'L' || *m == 'C' || *m == 'R')
1062                         m++;
1063                 strncpy(id, mm, i = m - mm);
1064                 id[i] = '\0';
1065                 if (!scanBoundary(&m))
1066                         return false;
1067                 _runways[id]._wind_shear = true;
1068         }
1069         if (!cnt)
1070                 _runways["ALL"]._wind_shear = true;
1071         _m = m;
1072         return true;
1073 }
1074
1075
1076 bool SGMetar::scanTrendForecast()
1077 {
1078         char *m = _m;
1079         if (strncmp(m, "NOSIG", 5))
1080                 return false;
1081
1082         m += 5;
1083         if (!scanBoundary(&m))
1084                 return false;
1085         _m = m;
1086         return true;
1087 }
1088
1089
1090 // (BLU|WHT|GRN|YLO|AMB|RED)
1091 static const struct Token colors[] = {
1092         { "BLU", "Blue" },      // 2500 ft,  8.0 km
1093         { "WHT", "White" },     // 1500 ft,  5.0 km
1094         { "GRN", "Green" },     //  700 ft,  3.7 km
1095         { "YLO", "Yellow" },    //  300 ft,  1.6 km
1096         { "AMB", "Amber" },     //  200 ft,  0.8 km
1097         { "RED", "Red" },       // <200 ft, <0.8 km
1098         { 0, 0 }
1099 };
1100
1101
1102 bool SGMetar::scanColorState()
1103 {
1104         char *m = _m;
1105         const struct Token *a;
1106         if (!(a = scanToken(&m, colors)))
1107                 return false;
1108         if (!scanBoundary(&m))
1109                 return false;
1110         //printf(Y"Code %s\n"N, a->text);
1111         _m = m;
1112         return true;
1113 }
1114
1115
1116 bool SGMetar::scanRemark()
1117 {
1118         if (strncmp(_m, "RMK", 3))
1119                 return false;
1120         _m += 3;
1121         if (!scanBoundary(&_m))
1122                 return false;
1123
1124         while (*_m) {
1125                 if (!scanRunwayReport()) {
1126                         while (*_m && !isspace(*_m))
1127                                 _m++;
1128                         scanBoundary(&_m);
1129                 }
1130         }
1131         return true;
1132 }
1133
1134
1135 bool SGMetar::scanRemainder()
1136 {
1137         char *m = _m;
1138         if (!(strncmp(m, "NOSIG", 5))) {
1139                 m += 5;
1140                 if (scanBoundary(&m))
1141                         _m = m; //_comment.push_back("No significant tendency");
1142         }
1143
1144         if (!scanBoundary(&m))
1145                 return false;
1146         _m = m;
1147         return true;
1148 }
1149
1150
1151 bool SGMetar::scanBoundary(char **s)
1152 {
1153         if (**s && !isspace(**s))
1154                 return false;
1155         while (isspace(**s))
1156                 (*s)++;
1157         return true;
1158 }
1159
1160
1161 int SGMetar::scanNumber(char **src, int *num, int min, int max)
1162 {
1163         int i;
1164         char *s = *src;
1165         *num = 0;
1166         for (i = 0; i < min; i++) {
1167                 if (!isdigit(*s))
1168                         return 0;
1169                 else
1170                         *num = *num * 10 + *s++ - '0';
1171         }
1172         for (; i < max && isdigit(*s); i++)
1173                 *num = *num * 10 + *s++ - '0';
1174         *src = s;
1175         return i;
1176 }
1177
1178
1179 // find longest match of str in list
1180 const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
1181 {
1182         const struct Token *longest = 0;
1183         int maxlen = 0, len;
1184         const char *s;
1185         for (int i = 0; (s = list[i].id); i++) {
1186                 len = strlen(s);
1187                 if (!strncmp(s, *str, len) && len > maxlen) {
1188                         maxlen = len;
1189                         longest = &list[i];
1190                 }
1191         }
1192         *str += maxlen;
1193         return longest;
1194 }
1195
1196
1197 void SGMetarCloud::set(double alt, int cov)
1198 {
1199         _altitude = alt;
1200         if (cov != -1)
1201                 _coverage = cov;
1202 }
1203
1204
1205 void SGMetarVisibility::set(double dist, int dir, int mod, int tend)
1206 {
1207         _distance = dist;
1208         if (dir != -1)
1209                 _direction = dir;
1210         if (mod != -1)
1211                 _modifier = mod;
1212         if (tend != 1)
1213                 _tendency = tend;
1214 }
1215
1216 #undef NaN