X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse-xml.c;h=3a84e296321d06b1453f86c2d868f78ff5b4cc8e;hb=3def2b1aacd9c018f1bfe9b7f8bce467239cc3b0;hp=dfe6a616e6e9042152fccc59ac61fcad35dab141;hpb=2cd2cafdf4fc1ea37872f172a62d3d38220adf64;p=ext%2Fsubsurface.git diff --git a/parse-xml.c b/parse-xml.c index dfe6a61..3a84e29 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -62,6 +62,28 @@ static int match(const char *pattern, int plen, return 1; } +/* + * We keep our internal data in well-specified units, but + * the input may come in some random format. This keeps track + * of the incoming units. + */ +static struct units { + enum { METERS, FEET } length; + enum { LITER, CUFT } volume; + enum { BAR, PSI } pressure; + enum { CELSIUS, FAHRENHEIT } temperature; + enum { KG, LBS } weight; +} units; + +/* We're going to default to SI units for input */ +static const struct units SI_units = { + .length = METERS, + .volume = LITER, + .pressure = BAR, + .temperature = CELSIUS, + .weight = KG +}; + /* * Dive info as it is being built up.. */ @@ -69,7 +91,7 @@ static int alloc_samples; static struct dive *dive; static struct sample *sample; static struct tm tm; -static int suunto; +static int suunto, uemis; static int event_index, gasmix_index; static time_t utc_mktime(struct tm *tm) @@ -164,13 +186,11 @@ static void divedatetime(char *buffer, void *_when) } union int_or_float { - long i; double fp; }; enum number_type { NEITHER, - INTEGER, FLOAT }; @@ -195,38 +215,37 @@ static enum number_type integer_or_float(char *buffer, union int_or_float *res) } } - res->i = val; - return INTEGER; + res->fp = val; + return FLOAT; } static void pressure(char *buffer, void *_press) { + double mbar; pressure_t *pressure = _press; union int_or_float val; switch (integer_or_float(buffer, &val)) { case FLOAT: - /* Maybe it's in Bar? */ - if (val.fp < 500.0) { - pressure->mbar = val.fp * 1000 + 0.5; + /* Just ignore zero values */ + if (!val.fp) + break; + switch (units.pressure) { + case BAR: + /* Assume mbar, but if it's really small, it's bar */ + mbar = val.fp; + if (mbar < 5000) + mbar = mbar * 1000; + break; + case PSI: + mbar = val.fp * 68.95; break; } - printf("Unknown fractional pressure reading %s\n", buffer); - break; - - case INTEGER: - /* - * Random integer? Maybe in PSI? Or millibar already? - * - * We assume that 5 bar is a ridiculous tank pressure, - * so if it's smaller than 5000, it's in PSI.. - */ - if (val.i < 5000) { - pressure->mbar = val.i * 68.95; + if (mbar > 5 && mbar < 500000) { + pressure->mbar = mbar + 0.5; break; } - pressure->mbar = val.i; - break; + /* fallthrough */ default: printf("Strange pressure reading %s\n", buffer); } @@ -239,12 +258,15 @@ static void depth(char *buffer, void *_depth) union int_or_float val; switch (integer_or_float(buffer, &val)) { - /* All values are probably in meters */ - case INTEGER: - val.fp = val.i; - /* fallthrough */ case FLOAT: - depth->mm = val.fp * 1000 + 0.5; + switch (units.length) { + case METERS: + depth->mm = val.fp * 1000 + 0.5; + break; + case FEET: + depth->mm = val.fp * 304.8 + 0.5; + break; + } break; default: printf("Strange depth reading %s\n", buffer); @@ -258,28 +280,19 @@ static void temperature(char *buffer, void *_temperature) union int_or_float val; switch (integer_or_float(buffer, &val)) { - /* C or F? Who knows? Let's default to Celsius */ - case INTEGER: - val.fp = val.i; - /* Fallthrough */ case FLOAT: /* Ignore zero. It means "none" */ if (!val.fp) break; /* Celsius */ - if (val.fp < 50.0) { + switch (units.temperature) { + case CELSIUS: temperature->mkelvin = (val.fp + 273.15) * 1000 + 0.5; break; - } - /* Fahrenheit */ - if (val.fp < 212.0) { + case FAHRENHEIT: temperature->mkelvin = (val.fp + 459.67) * 5000/9; break; } - /* Kelvin or already millikelvin */ - if (val.fp < 1000.0) - val.fp *= 1000; - temperature->mkelvin = val.fp; break; default: printf("Strange temperature reading %s\n", buffer); @@ -319,10 +332,6 @@ static void percent(char *buffer, void *_fraction) union int_or_float val; switch (integer_or_float(buffer, &val)) { - /* C or F? Who knows? Let's default to Celsius */ - case INTEGER: - val.fp = val.i; - /* Fallthrough */ case FLOAT: if (val.fp <= 100.0) fraction->permille = val.fp * 10 + 0.5; @@ -354,9 +363,93 @@ static void utf8_string(char *buffer, void *_res) *(char **)_res = buffer; } +/* + * Uemis water_pressure. In centibar. And when converting to + * depth, I'm just going to always use saltwater, because I + * think "true depth" is just stupid. From a diving standpoint, + * "true depth" is pretty much completely pointless, unless + * you're doing some kind of underwater surveying work. + * + * So I give water depths in "pressure depth", always assuming + * salt water. So one atmosphere per 10m. + */ +static void water_pressure(char *buffer, void *_depth) +{ + depth_t *depth = _depth; + union int_or_float val; + double atm, cm; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + if (!val.fp) + break; + /* cbar to atm */ + atm = (val.fp / 100) / 1.01325; + /* + * atm to cm. Why not mm? The precision just isn't + * there. + */ + cm = 100 * (atm - 1) + 0.5; + if (cm > 0) { + depth->mm = 10 * (long)cm; + break; + } + default: + fprintf(stderr, "Strange water pressure '%s'\n", buffer); + } + free(buffer); +} + #define MATCH(pattern, fn, dest) \ match(pattern, strlen(pattern), name, len, fn, buf, dest) +static void get_index(char *buffer, void *_i) +{ + int *i = _i; + *i = atoi(buffer); + free(buffer); +} + +static void centibar(char *buffer, void *_pressure) +{ + pressure_t *pressure = _pressure; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + pressure->mbar = val.fp * 10 + 0.5; + break; + default: + fprintf(stderr, "Strange centibar pressure '%s'\n", buffer); + } + free(buffer); +} + +static void decicelsius(char *buffer, void *_temp) +{ + temperature_t *temp = _temp; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + temp->mkelvin = (val.fp/10 + 273.15) * 1000 + 0.5; + break; + default: + fprintf(stderr, "Strange julian date: %s", buffer); + } + free(buffer); +} + +static int uemis_fill_sample(struct sample *sample, const char *name, int len, char *buf) +{ + return MATCH(".reading.dive_time", sampletime, &sample->time) || + MATCH(".reading.water_pressure", water_pressure, &sample->depth) || + MATCH(".reading.active_tank", get_index, &sample->tankindex) || + MATCH(".reading.tank_pressure", centibar, &sample->tankpressure) || + MATCH(".reading.dive_temperature", decicelsius, &sample->temperature) || + 0; +} + /* We're in samples - try to convert the random xml value to something useful */ static void try_to_fill_sample(struct sample *sample, const char *name, char *buf) { @@ -378,6 +471,11 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu if (MATCH(".sample.time", sampletime, &sample->time)) return; + if (uemis) { + if (uemis_fill_sample(sample, name, len, buf)) + return; + } + nonmatch("sample", name, buf); } @@ -396,6 +494,94 @@ static int suunto_dive_match(struct dive *dive, const char *name, int len, char MATCH(".hepct_3", percent, &dive->gasmix[3].he); } +static int buffer_value(char *buffer) +{ + int val = atoi(buffer); + free(buffer); + return val; +} + +static void uemis_length_unit(char *buffer, void *_unused) +{ + units.length = buffer_value(buffer) ? FEET : METERS; +} + +static void uemis_volume_unit(char *buffer, void *_unused) +{ + units.volume = buffer_value(buffer) ? CUFT : LITER; +} + +static void uemis_pressure_unit(char *buffer, void *_unused) +{ +#if 0 + units.pressure = buffer_value(buffer) ? PSI : BAR; +#endif +} + +static void uemis_temperature_unit(char *buffer, void *_unused) +{ + units.temperature = buffer_value(buffer) ? FAHRENHEIT : CELSIUS; +} + +static void uemis_weight_unit(char *buffer, void *_unused) +{ + units.weight = buffer_value(buffer) ? LBS : KG; +} + +static void uemis_time_unit(char *buffer, void *_unused) +{ +} + +static void uemis_date_unit(char *buffer, void *_unused) +{ +} + +/* Modified julian day, yay! */ +static void uemis_date_time(char *buffer, void *_when) +{ + time_t *when = _when; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + *when = (val.fp - 40587.5) * 86400; + break; + default: + fprintf(stderr, "Strange julian date: %s", buffer); + } + free(buffer); +} + +/* + * Uemis doesn't know time zones. You need to do them as + * minutes, not hours. + * + * But that's ok, we don't track timezones yet either. We + * just turn everything into "localtime expressed as UTC". + */ +static void uemis_time_zone(char *buffer, void *_when) +{ + time_t *when = _when; + signed char tz = atoi(buffer); + + *when += tz * 3600; +} + +static int uemis_dive_match(struct dive *dive, const char *name, int len, char *buf) +{ + return MATCH(".units.length", uemis_length_unit, &units) || + MATCH(".units.volume", uemis_volume_unit, &units) || + MATCH(".units.pressure", uemis_pressure_unit, &units) || + MATCH(".units.temperature", uemis_temperature_unit, &units) || + MATCH(".units.weight", uemis_weight_unit, &units) || + MATCH(".units.time", uemis_time_unit, &units) || + MATCH(".units.date", uemis_date_unit, &units) || + MATCH(".date_time", uemis_date_time, &dive->when) || + MATCH(".time_zone", uemis_time_zone, &dive->when) || + MATCH(".ambient.temperature", decicelsius, &dive->airtemp) || + 0; +} + /* We're in the top-level dive xml. Try to convert whatever value to a dive value */ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) { @@ -444,12 +630,10 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) if (suunto && suunto_dive_match(dive, name, len, buf)) return; - nonmatch("dive", name, buf); -} + if (uemis && uemis_dive_match(dive, name, len, buf)) + return; -static unsigned int dive_size(int samples) -{ - return sizeof(struct dive) + samples*sizeof(struct sample); + nonmatch("dive", name, buf); } /* @@ -541,6 +725,7 @@ static void dive_end(void) static void suunto_start(void) { suunto++; + units = SI_units; } static void suunto_end(void) @@ -548,6 +733,16 @@ static void suunto_end(void) suunto--; } +static void uemis_start(void) +{ + uemis++; + units = SI_units; +} + +static void uemis_end(void) +{ +} + static void event_start(void) { } @@ -717,8 +912,10 @@ static struct nesting { { "SUUNTO", suunto_start, suunto_end }, { "sample", sample_start, sample_end }, { "SAMPLE", sample_start, sample_end }, + { "reading", sample_start, sample_end }, { "event", event_start, event_end }, { "gasmix", gasmix_start, gasmix_end }, + { "pre_dive", uemis_start, uemis_end }, { NULL, } }; @@ -743,6 +940,21 @@ static void traverse(xmlNode *root) } } +/* Per-file reset */ +static void reset_all(void) +{ + /* + * We reset the units for each file. You'd think it was + * a per-dive property, but I'm not going to trust people + * to do per-dive setup. If the xml does have per-dive + * data within one file, we might have to reset it per + * dive for that format. + */ + units = SI_units; + suunto = 0; + uemis = 0; +} + void parse_xml_file(const char *filename) { xmlDoc *doc; @@ -753,6 +965,7 @@ void parse_xml_file(const char *filename) return; } + reset_all(); dive_start(); traverse(xmlDocGetRootElement(doc)); dive_end();