X-Git-Url: http://git.tdb.fi/?p=ext%2Fsubsurface.git;a=blobdiff_plain;f=parse-xml.c;h=5159a334f9153f65b010f0e1cf5c4845cebcf530;hp=3221111c748bf37ec9825533b6df8e79a7ce9f39;hb=HEAD;hpb=6b075e0339f419555f08ece3a6c4a29407ecc32b diff --git a/parse-xml.c b/parse-xml.c index 3221111..5159a33 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -3,11 +3,17 @@ #include #include #include +#include +#define __USE_XOPEN #include #include #include +#ifdef XSLT +#include +#endif #include "dive.h" +#include "uemis.h" int verbose; @@ -16,7 +22,7 @@ struct dive_table dive_table; /* * Add a dive into the dive_table array */ -static void record_dive(struct dive *dive) +void record_dive(struct dive *dive) { int nr = dive_table.nr, allocated = dive_table.allocated; struct dive **dives = dive_table.dives; @@ -33,6 +39,70 @@ static void record_dive(struct dive *dive) dive_table.nr = nr+1; } +void record_trip(struct dive *trip) +{ + dive_trip_list = insert_trip(trip, dive_trip_list); +} + +static void delete_dive_renumber(struct dive **dives, int i, int nr) +{ + struct dive *dive = dives[i]; + int number = dive->number, j; + + if (!number) + return; + + /* + * Check that all numbered dives after the deleted + * ones are consecutive, return without renumbering + * if that is not the case. + */ + for (j = i+1; j < nr; j++) { + struct dive *next = dives[j]; + if (!next->number) + break; + number++; + if (next->number != number) + return; + } + + /* + * Ok, we hit the end of the dives or a unnumbered + * dive - renumber. + */ + for (j = i+1 ; j < nr; j++) { + struct dive *next = dives[j]; + if (!next->number) + break; + next->number--; + } +} + +/* + * Remove a dive from the dive_table array + */ +void delete_dive(struct dive *dive) +{ + int nr = dive_table.nr, i; + struct dive **dives = dive_table.dives; + + /* + * Stupid. We know the dive table is sorted by date, + * we could do a binary lookup. Sue me. + */ + for (i = 0; i < nr; i++) { + struct dive *d = dives[i]; + if (d != dive) + continue; + /* should we re-number? */ + delete_dive_renumber(dives, i, nr); + memmove(dives+i, dives+i+1, sizeof(struct dive *)*(nr-i-1)); + dives[nr] = NULL; + dive_table.nr = nr-1; + break; + } +} + static void start_match(const char *type, const char *name, char *buffer) { if (verbose > 2) @@ -62,21 +132,17 @@ static int match(const char *pattern, int plen, return 1; } + +struct units input_units; + /* - * 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. + * We're going to default to SI units for input. Yes, + * technically the SI unit for pressure is Pascal, but + * we default to bar (10^5 pascal), which people + * actually use. Similarly, C instead of Kelvin. + * And kg instead of g. */ -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 = { +const struct units SI_units = { .length = METERS, .volume = LITER, .pressure = BAR, @@ -84,17 +150,37 @@ static const struct units SI_units = { .weight = KG }; +const struct units IMPERIAL_units = { + .length = FEET, + .volume = CUFT, + .pressure = PSI, + .temperature = FAHRENHEIT, + .weight = LBS +}; + /* * Dive info as it is being built up.. */ -static int alloc_samples; -static struct dive *dive; -static struct sample *sample; -static struct tm tm; -static int suunto, uemis; -static int event_index, cylinder_index; - -static time_t utc_mktime(struct tm *tm) +static struct dive *cur_dive, *cur_trip = NULL; +static struct sample *cur_sample; +static struct { + int active; + duration_t time; + int type, flags, value; + const char *name; +} cur_event; +static struct tm cur_tm; +static int cur_cylinder_index, cur_ws_index; + +static enum import_source { + UNKNOWN, + LIBDIVECOMPUTER, + UEMIS, + DIVINGLOG, + UDDF, +} import_source; + +time_t utc_mktime(struct tm *tm) { static const int mdays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 @@ -130,22 +216,22 @@ static void divedate(char *buffer, void *_when) time_t *when = _when; int success = 0; - success = tm.tm_sec | tm.tm_min | tm.tm_hour; + success = cur_tm.tm_sec | cur_tm.tm_min | cur_tm.tm_hour; if (sscanf(buffer, "%d.%d.%d", &d, &m, &y) == 3) { - tm.tm_year = y; - tm.tm_mon = m-1; - tm.tm_mday = d; + cur_tm.tm_year = y; + cur_tm.tm_mon = m-1; + cur_tm.tm_mday = d; } else if (sscanf(buffer, "%d-%d-%d", &y, &m, &d) == 3) { - tm.tm_year = y; - tm.tm_mon = m-1; - tm.tm_mday = d; + cur_tm.tm_year = y; + cur_tm.tm_mon = m-1; + cur_tm.tm_mday = d; } else { fprintf(stderr, "Unable to parse date '%s'\n", buffer); success = 0; } if (success) - *when = utc_mktime(&tm); + *when = utc_mktime(&cur_tm); free(buffer); } @@ -156,11 +242,11 @@ static void divetime(char *buffer, void *_when) time_t *when = _when; if (sscanf(buffer, "%d:%d:%d", &h, &m, &s) >= 2) { - tm.tm_hour = h; - tm.tm_min = m; - tm.tm_sec = s; - if (tm.tm_year) - *when = utc_mktime(&tm); + cur_tm.tm_hour = h; + cur_tm.tm_min = m; + cur_tm.tm_sec = s; + if (cur_tm.tm_year) + *when = utc_mktime(&cur_tm); } free(buffer); } @@ -174,13 +260,13 @@ static void divedatetime(char *buffer, void *_when) if (sscanf(buffer, "%d-%d-%d %d:%d:%d", &y, &m, &d, &hr, &min, &sec) == 6) { - tm.tm_year = y; - tm.tm_mon = m-1; - tm.tm_mday = d; - tm.tm_hour = hr; - tm.tm_min = min; - tm.tm_sec = sec; - *when = utc_mktime(&tm); + cur_tm.tm_year = y; + cur_tm.tm_mon = m-1; + cur_tm.tm_mday = d; + cur_tm.tm_hour = hr; + cur_tm.tm_min = min; + cur_tm.tm_sec = sec; + *when = utc_mktime(&cur_tm); } free(buffer); } @@ -230,7 +316,10 @@ static void pressure(char *buffer, void *_press) /* Just ignore zero values */ if (!val.fp) break; - switch (units.pressure) { + switch (input_units.pressure) { + case PASCAL: + mbar = val.fp / 100; + break; case BAR: /* Assume mbar, but if it's really small, it's bar */ mbar = val.fp; @@ -259,7 +348,7 @@ static void depth(char *buffer, void *_depth) switch (integer_or_float(buffer, &val)) { case FLOAT: - switch (units.length) { + switch (input_units.length) { case METERS: depth->mm = val.fp * 1000 + 0.5; break; @@ -274,6 +363,27 @@ static void depth(char *buffer, void *_depth) free(buffer); } +static void weight(char *buffer, void *_weight) +{ + weight_t *weight = _weight; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + switch (input_units.weight) { + case KG: + weight->grams = val.fp * 1000 + 0.5; + break; + case LBS: + weight->grams = val.fp * 453.6 + 0.5; + break; + } + break; + default: + printf("Strange depth reading %s\n", buffer); + } +} + static void temperature(char *buffer, void *_temperature) { temperature_t *temperature = _temperature; @@ -285,7 +395,10 @@ static void temperature(char *buffer, void *_temperature) if (!val.fp) break; /* Celsius */ - switch (units.temperature) { + switch (input_units.temperature) { + case KELVIN: + temperature->mkelvin = val.fp * 1000; + break; case CELSIUS: temperature->mkelvin = (val.fp + 273.15) * 1000 + 0.5; break; @@ -349,7 +462,7 @@ static void gasmix(char *buffer, void *_fraction) /* libdivecomputer does negative percentages. */ if (*buffer == '-') return; - if (cylinder_index < MAX_CYLINDERS) + if (cur_cylinder_index < MAX_CYLINDERS) percent(buffer, _fraction); } @@ -393,20 +506,20 @@ static void utf8_string(char *buffer, void *_res) static void water_pressure(char *buffer, void *_depth) { depth_t *depth = _depth; - union int_or_float val; + union int_or_float val; double atm, cm; - switch (integer_or_float(buffer, &val)) { - case FLOAT: + switch (integer_or_float(buffer, &val)) { + case FLOAT: if (!val.fp) break; /* cbar to atm */ - atm = (val.fp / 100) / 1.01325; + atm = bar_to_atm(val.fp * 10); /* * atm to cm. Why not mm? The precision just isn't * there. */ - cm = 100 * (atm - 1) + 0.5; + cm = 100 * atm + 0.5; if (cm > 0) { depth->mm = 10 * (long)cm; break; @@ -427,6 +540,17 @@ static void get_index(char *buffer, void *_i) free(buffer); } +static void get_tripflag(char *buffer, void *_tf) +{ + tripflag_t *tf = _tf; + tripflag_t i; + + *tf = TF_NONE; + for (i = NO_TRIP; i < NUM_TRIPFLAGS; i++) + if(! strcmp(buffer, tripflag_names[i])) + *tf = i; +} + static void centibar(char *buffer, void *_pressure) { pressure_t *pressure = _pressure; @@ -445,10 +569,10 @@ static void centibar(char *buffer, void *_pressure) static void decicelsius(char *buffer, void *_temp) { temperature_t *temp = _temp; - union int_or_float val; + union int_or_float val; - switch (integer_or_float(buffer, &val)) { - case FLOAT: + switch (integer_or_float(buffer, &val)) { + case FLOAT: temp->mkelvin = (val.fp/10 + 273.15) * 1000 + 0.5; break; default: @@ -467,6 +591,110 @@ static int uemis_fill_sample(struct sample *sample, const char *name, int len, c 0; } +/* + * Divinglog is crazy. The temperatures are in celsius. EXCEPT + * for the sample temperatures, that are in Fahrenheit. + * WTF? + * + * Oh, and I think Diving Log *internally* probably kept them + * in celsius, because I'm seeing entries like + * + * 32.0 + * + * in there. Which is freezing, aka 0 degC. I bet the "0" is + * what Diving Log uses for "no temperature". + * + * So throw away crap like that. + */ +static void fahrenheit(char *buffer, void *_temperature) +{ + temperature_t *temperature = _temperature; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + /* Floating point equality is evil, but works for small integers */ + if (val.fp == 32.0) + break; + temperature->mkelvin = (val.fp + 459.67) * 5000/9; + break; + default: + fprintf(stderr, "Crazy Diving Log temperature reading %s\n", buffer); + } + free(buffer); +} + +/* + * Did I mention how bat-shit crazy divinglog is? The sample + * pressures are in PSI. But the tank working pressure is in + * bar. WTF^2? + * + * Crazy stuff like this is why subsurface has everything in + * these inconvenient typed structures, and you have to say + * "pressure->mbar" to get the actual value. Exactly so that + * you can never have unit confusion. + */ +static void psi(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 * 68.95 + 0.5; + break; + default: + fprintf(stderr, "Crazy Diving Log PSI reading %s\n", buffer); + } + free(buffer); +} + +static int divinglog_fill_sample(struct sample *sample, const char *name, int len, char *buf) +{ + return MATCH(".p.time", sampletime, &sample->time) || + MATCH(".p.depth", depth, &sample->depth) || + MATCH(".p.temp", fahrenheit, &sample->temperature) || + MATCH(".p.press1", psi, &sample->cylinderpressure) || + 0; +} + +static int uddf_fill_sample(struct sample *sample, const char *name, int len, char *buf) +{ + return MATCH(".divetime", sampletime, &sample->time) || + MATCH(".depth", depth, &sample->depth) || + MATCH(".temperature", temperature, &sample->temperature) || + MATCH(".tankpressure", pressure, &sample->cylinderpressure) || + 0; +} + +static void eventtime(char *buffer, void *_duration) +{ + duration_t *duration = _duration; + sampletime(buffer, duration); + if (cur_sample) + duration->seconds += cur_sample->time.seconds; +} + +static void try_to_fill_event(const char *name, char *buf) +{ + int len = strlen(name); + + start_match("event", name, buf); + if (MATCH(".event", utf8_string, &cur_event.name)) + return; + if (MATCH(".name", utf8_string, &cur_event.name)) + return; + if (MATCH(".time", eventtime, &cur_event.time)) + return; + if (MATCH(".type", get_index, &cur_event.type)) + return; + if (MATCH(".flags", get_index, &cur_event.flags)) + return; + if (MATCH(".value", get_index, &cur_event.value)) + return; + nonmatch("event", name, buf); +} + /* 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) { @@ -477,6 +705,8 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu return; if (MATCH(".sample.cylpress", pressure, &sample->cylinderpressure)) return; + if (MATCH(".sample.cylinderindex", get_index, &sample->cylinderindex)) + return; if (MATCH(".sample.depth", depth, &sample->depth)) return; if (MATCH(".sample.temp", temperature, &sample->temperature)) @@ -488,29 +718,67 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu if (MATCH(".sample.time", sampletime, &sample->time)) return; - if (uemis) { + switch (import_source) { + case UEMIS: if (uemis_fill_sample(sample, name, len, buf)) return; + break; + + case DIVINGLOG: + if (divinglog_fill_sample(sample, name, len, buf)) + return; + break; + + case UDDF: + if (uddf_fill_sample(sample, name, len, buf)) + return; + break; + + default: + break; } nonmatch("sample", name, buf); } -/* - * Crazy suunto xml. Look at how those o2/he things match up. - */ -static int suunto_dive_match(struct dive *dive, const char *name, int len, char *buf) -{ - return MATCH(".o2pct", percent, &dive->cylinder[0].gasmix.o2) || - MATCH(".hepct_0", percent, &dive->cylinder[0].gasmix.he) || - MATCH(".o2pct_2", percent, &dive->cylinder[1].gasmix.o2) || - MATCH(".hepct_1", percent, &dive->cylinder[1].gasmix.he) || - MATCH(".o2pct_3", percent, &dive->cylinder[2].gasmix.o2) || - MATCH(".hepct_2", percent, &dive->cylinder[2].gasmix.he) || - MATCH(".o2pct_4", percent, &dive->cylinder[3].gasmix.o2) || - MATCH(".hepct_3", percent, &dive->cylinder[3].gasmix.he) || - MATCH(".cylindersize", cylindersize, &dive->cylinder[0].type.size) || - MATCH(".cylinderworkpressure", pressure, &dive->cylinder[0].type.workingpressure) || +static const char *country, *city; + +static void divinglog_place(char *place, void *_location) +{ + char **location = _location; + char buffer[256], *p; + int len; + + len = snprintf(buffer, sizeof(buffer), + "%s%s%s%s%s", + place, + city ? ", " : "", + city ? city : "", + country ? ", " : "", + country ? country : ""); + + p = malloc(len+1); + memcpy(p, buffer, len+1); + *location = p; + + city = NULL; + country = NULL; +} + +static int divinglog_dive_match(struct dive **divep, const char *name, int len, char *buf) +{ + struct dive *dive = *divep; + + return MATCH(".divedate", divedate, &dive->when) || + MATCH(".entrytime", divetime, &dive->when) || + MATCH(".depth", depth, &dive->maxdepth) || + MATCH(".tanksize", cylindersize, &dive->cylinder[0].type.size) || + MATCH(".presw", pressure, &dive->cylinder[0].type.workingpressure) || + MATCH(".comments", utf8_string, &dive->notes) || + MATCH(".buddy.names", utf8_string, &dive->buddy) || + MATCH(".country.name", utf8_string, &country) || + MATCH(".city.name", utf8_string, &city) || + MATCH(".place.name", divinglog_place, &dive->location) || 0; } @@ -523,29 +791,29 @@ static int buffer_value(char *buffer) static void uemis_length_unit(char *buffer, void *_unused) { - units.length = buffer_value(buffer) ? FEET : METERS; + input_units.length = buffer_value(buffer) ? FEET : METERS; } static void uemis_volume_unit(char *buffer, void *_unused) { - units.volume = buffer_value(buffer) ? CUFT : LITER; + input_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; + input_units.pressure = buffer_value(buffer) ? PSI : BAR; #endif } static void uemis_temperature_unit(char *buffer, void *_unused) { - units.temperature = buffer_value(buffer) ? FAHRENHEIT : CELSIUS; + input_units.temperature = buffer_value(buffer) ? FAHRENHEIT : CELSIUS; } static void uemis_weight_unit(char *buffer, void *_unused) { - units.weight = buffer_value(buffer) ? LBS : KG; + input_units.weight = buffer_value(buffer) ? LBS : KG; } static void uemis_time_unit(char *buffer, void *_unused) @@ -560,11 +828,11 @@ static void uemis_date_unit(char *buffer, void *_unused) static void uemis_date_time(char *buffer, void *_when) { time_t *when = _when; - union int_or_float val; + union int_or_float val; - switch (integer_or_float(buffer, &val)) { - case FLOAT: - *when = (val.fp - 40587.5) * 86400; + switch (integer_or_float(buffer, &val)) { + case FLOAT: + *when = (val.fp - 40587) * 86400; break; default: fprintf(stderr, "Strange julian date: %s", buffer); @@ -581,33 +849,237 @@ static void uemis_date_time(char *buffer, void *_when) */ static void uemis_time_zone(char *buffer, void *_when) { +#if 0 /* seems like this is only used to display it correctly + * the stored time appears to be UTC */ + time_t *when = _when; signed char tz = atoi(buffer); *when += tz * 3600; +#endif +} + +static void uemis_ts(char *buffer, void *_when) +{ + struct tm tm; + time_t *when = _when; + + memset(&tm, 0, sizeof(tm)); + sscanf(buffer,"%d-%d-%dT%d:%d:%d", + &tm.tm_year, &tm.tm_mon, &tm.tm_mday, + &tm.tm_hour, &tm.tm_min, &tm.tm_sec); + tm.tm_mon -= 1; + tm.tm_year -= 1900; + *when = utc_mktime(&tm); + +} + +static void uemis_duration(char *buffer, void *_duration) +{ + duration_t *duration = _duration; + duration->seconds = atof(buffer) * 60 + 0.5; +} + +/* 0 - air ; 1 - nitrox1 ; 2 - nitrox2 ; 3 = nitrox3 */ +static int uemis_gas_template; + +/* + * Christ. Uemis tank data is a total mess. + * + * We're passed a "virtual cylinder" (0 - 6) for the different + * Uemis tank cases ("air", "nitrox_1", "nitrox_2.{bottom,deco}" + * and "nitrox_3.{bottom,deco,travel}". We need to turn that + * into the actual cylinder data depending on the gas template, + * and ignore the ones that are irrelevant for that template. + * + * So for "template 2" (nitrox_2), we ignore virtual tanks 0-1 + * (which are "air" and "nitrox_1" respectively), and tanks 4-6 + * (which are the three "nitrox_3" tanks), and we turn virtual + * tanks 2/3 into actual tanks 0/1. + * + * Confused yet? + */ +static int uemis_cylinder_index(void *_cylinder) +{ + cylinder_t *cylinder = _cylinder; + unsigned int index = cylinder - cur_dive->cylinder; + + if (index > 6) { + fprintf(stderr, "Uemis cylinder pointer calculations broken\n"); + return -1; + } + switch(uemis_gas_template) { + case 1: /* Dive uses tank 1 */ + index -= 1; + /* Fallthrough */ + case 0: /* Dive uses tank 0 */ + if (index) + index = -1; + break; + case 2: /* Dive uses tanks 2-3 */ + index -= 2; + if (index > 1) + index = -1; + break; + case 3: /* Dive uses tanks 4-6 */ + index -= 4; + if (index > 2) + index = -1; + break; + } + return index; +} + +static void uemis_cylindersize(char *buffer, void *_cylinder) +{ + int index = uemis_cylinder_index(_cylinder); + if (index >= 0) + cylindersize(buffer, &cur_dive->cylinder[index].type.size); } -static int uemis_dive_match(struct dive *dive, const char *name, int len, char *buf) +static void uemis_percent(char *buffer, void *_cylinder) { - 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) || + int index = uemis_cylinder_index(_cylinder); + if (index >= 0) + percent(buffer, &cur_dive->cylinder[index].gasmix.o2); +} + +static int uemis_dive_match(struct dive **divep, const char *name, int len, char *buf) +{ + struct dive *dive = *divep; + + return MATCH(".units.length", uemis_length_unit, &input_units) || + MATCH(".units.volume", uemis_volume_unit, &input_units) || + MATCH(".units.pressure", uemis_pressure_unit, &input_units) || + MATCH(".units.temperature", uemis_temperature_unit, &input_units) || + MATCH(".units.weight", uemis_weight_unit, &input_units) || + MATCH(".units.time", uemis_time_unit, &input_units) || + MATCH(".units.date", uemis_date_unit, &input_units) || MATCH(".date_time", uemis_date_time, &dive->when) || MATCH(".time_zone", uemis_time_zone, &dive->when) || MATCH(".ambient.temperature", decicelsius, &dive->airtemp) || + MATCH(".gas.template", get_index, &uemis_gas_template) || + MATCH(".air.bottom_tank.size", uemis_cylindersize, dive->cylinder + 0) || + MATCH(".air.bottom_tank.oxygen", uemis_percent, dive->cylinder + 0) || + MATCH(".nitrox_1.bottom_tank.size", uemis_cylindersize, dive->cylinder + 1) || + MATCH(".nitrox_1.bottom_tank.oxygen", uemis_percent, dive->cylinder + 1) || + MATCH(".nitrox_2.bottom_tank.size", uemis_cylindersize, dive->cylinder + 2) || + MATCH(".nitrox_2.bottom_tank.oxygen", uemis_percent, dive->cylinder + 2) || + MATCH(".nitrox_2.deco_tank.size", uemis_cylindersize, dive->cylinder + 3) || + MATCH(".nitrox_2.deco_tank.oxygen", uemis_percent, dive->cylinder + 3) || + MATCH(".nitrox_3.bottom_tank.size", uemis_cylindersize, dive->cylinder + 4) || + MATCH(".nitrox_3.bottom_tank.oxygen", uemis_percent, dive->cylinder + 4) || + MATCH(".nitrox_3.deco_tank.size", uemis_cylindersize, dive->cylinder + 5) || + MATCH(".nitrox_3.deco_tank.oxygen", uemis_percent, dive->cylinder + 5) || + MATCH(".nitrox_3.travel_tank.size", uemis_cylindersize, dive->cylinder + 6) || + MATCH(".nitrox_3.travel_tank.oxygen", uemis_percent, dive->cylinder + 6) || + MATCH(".dive.val.float", uemis_duration, &dive->duration) || + MATCH(".dive.val.ts", uemis_ts, &dive->when) || + MATCH(".dive.val.bin", uemis_parse_divelog_binary, divep) || 0; } +/* + * Uddf specifies ISO 8601 time format. + * + * There are many variations on that. This handles the useful cases. + */ +static void uddf_datetime(char *buffer, void *_when) +{ + char c; + int y,m,d,hh,mm,ss; + time_t *when = _when; + struct tm tm = { 0 }; + int i; + + i = sscanf(buffer, "%d-%d-%d%c%d:%d:%d", &y, &m, &d, &c, &hh, &mm, &ss); + if (i == 7) + goto success; + ss = 0; + if (i == 6) + goto success; + + i = sscanf(buffer, "%04d%02d%02d%c%02d%02d%02d", &y, &m, &d, &c, &hh, &mm, &ss); + if (i == 7) + goto success; + ss = 0; + if (i == 6) + goto success; +bad_date: + printf("Bad date time %s\n", buffer); + free(buffer); + return; + +success: + if (c != 'T' && c != ' ') + goto bad_date; + tm.tm_year = y; + tm.tm_mon = m - 1; + tm.tm_mday = d; + tm.tm_hour = hh; + tm.tm_min = mm; + tm.tm_sec = ss; + *when = utc_mktime(&tm); + free(buffer); +} + +static int uddf_dive_match(struct dive **divep, const char *name, int len, char *buf) +{ + struct dive *dive = *divep; + + return MATCH(".datetime", uddf_datetime, &dive->when) || + MATCH(".diveduration", duration, &dive->duration) || + MATCH(".greatestdepth", depth, &dive->maxdepth) || + 0; +} + +static void gps_location(char *buffer, void *_dive) +{ + int i; + struct dive *dive = _dive; + double latitude, longitude; + + i = sscanf(buffer, "%lf %lf", &latitude, &longitude); + if (i == 2) { + dive->latitude = latitude; + dive->longitude = longitude; + } + free(buffer); +} + /* 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) +static void try_to_fill_dive(struct dive **divep, const char *name, char *buf) { int len = strlen(name); start_match("dive", name, buf); + + switch (import_source) { + case UEMIS: + if (uemis_dive_match(divep, name, len, buf)) + return; + break; + + case DIVINGLOG: + if (divinglog_dive_match(divep, name, len, buf)) + return; + break; + + case UDDF: + if (uddf_dive_match(divep, name, len, buf)) + return; + break; + + default: + break; + } + + struct dive *dive = *divep; + + if (MATCH(".number", get_index, &dive->number)) + return; + if (MATCH(".tripflag", get_tripflag, &dive->tripflag)) + return; if (MATCH(".date", divedate, &dive->when)) return; if (MATCH(".time", divetime, &dive->when)) @@ -618,6 +1090,10 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) return; if (MATCH(".meandepth", depth, &dive->meandepth)) return; + if (MATCH(".depth.max", depth, &dive->maxdepth)) + return; + if (MATCH(".depth.mean", depth, &dive->meandepth)) + return; if (MATCH(".duration", duration, &dive->duration)) return; if (MATCH(".divetime", duration, &dive->duration)) @@ -630,199 +1106,162 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) return; if (MATCH(".watertemp", temperature, &dive->watertemp)) return; - if (MATCH(".cylinderstartpressure", pressure, &dive->beginning_pressure)) + if (MATCH(".temperature.air", temperature, &dive->airtemp)) + return; + if (MATCH(".temperature.water", temperature, &dive->watertemp)) + return; + if (MATCH(".cylinderstartpressure", pressure, &dive->cylinder[0].start)) return; - if (MATCH(".cylinderendpressure", pressure, &dive->end_pressure)) + if (MATCH(".cylinderendpressure", pressure, &dive->cylinder[0].end)) + return; + if (MATCH(".gps", gps_location, dive)) return; if (MATCH(".location", utf8_string, &dive->location)) return; + if (MATCH(".suit", utf8_string, &dive->suit)) + return; + if (MATCH(".divesuit", utf8_string, &dive->suit)) + return; if (MATCH(".notes", utf8_string, &dive->notes)) return; - - if (MATCH(".cylinder.size", cylindersize, &dive->cylinder[cylinder_index].type.size)) + if (MATCH(".divemaster", utf8_string, &dive->divemaster)) return; - if (MATCH(".cylinder.workpressure", pressure, &dive->cylinder[cylinder_index].type.workingpressure)) + if (MATCH(".buddy", utf8_string, &dive->buddy)) return; - - if (MATCH(".o2", gasmix, &dive->cylinder[cylinder_index].gasmix.o2)) + if (MATCH(".rating", get_index, &dive->rating)) return; - if (MATCH(".n2", gasmix_nitrogen, &dive->cylinder[cylinder_index].gasmix)) + if (MATCH(".cylinder.size", cylindersize, &dive->cylinder[cur_cylinder_index].type.size)) return; - if (MATCH(".he", gasmix, &dive->cylinder[cylinder_index].gasmix.he)) + if (MATCH(".cylinder.workpressure", pressure, &dive->cylinder[cur_cylinder_index].type.workingpressure)) return; - - /* Suunto XML files are some crazy sh*t. */ - if (suunto && suunto_dive_match(dive, name, len, buf)) + if (MATCH(".cylinder.description", utf8_string, &dive->cylinder[cur_cylinder_index].type.description)) return; - - if (uemis && uemis_dive_match(dive, name, len, buf)) + if (MATCH(".cylinder.start", pressure, &dive->cylinder[cur_cylinder_index].start)) + return; + if (MATCH(".cylinder.end", pressure, &dive->cylinder[cur_cylinder_index].end)) + return; + if (MATCH(".weightsystem.description", utf8_string, &dive->weightsystem[cur_ws_index].description)) + return; + if (MATCH(".weightsystem.weight", weight, &dive->weightsystem[cur_ws_index].weight)) + return; + if (MATCH("weight", weight, &dive->weightsystem[cur_ws_index].weight)) + return; + if (MATCH(".o2", gasmix, &dive->cylinder[cur_cylinder_index].gasmix.o2)) + return; + if (MATCH(".n2", gasmix_nitrogen, &dive->cylinder[cur_cylinder_index].gasmix)) + return; + if (MATCH(".he", gasmix, &dive->cylinder[cur_cylinder_index].gasmix.he)) return; nonmatch("dive", name, buf); } -/* - * File boundaries are dive boundaries. But sometimes there are - * multiple dives per file, so there can be other events too that - * trigger a "new dive" marker and you may get some nesting due - * to that. Just ignore nesting levels. - */ -static void dive_start(void) +/* We're in the top-level trip xml. Try to convert whatever value to a trip value */ +static void try_to_fill_trip(struct dive **divep, const char *name, char *buf) { - unsigned int size; - - if (dive) - return; - - alloc_samples = 5; - size = dive_size(alloc_samples); - dive = malloc(size); - if (!dive) - exit(1); - memset(dive, 0, size); - memset(&tm, 0, sizeof(tm)); -} + int len = strlen(name); -static void sanitize_gasmix(gasmix_t *mix) -{ - unsigned int o2, he; + start_match("trip", name, buf); - o2 = mix->o2.permille; - he = mix->he.permille; + struct dive *dive = *divep; - /* Regular air: leave empty */ - if (!he) { - if (!o2) - return; - /* 20.9% or 21% O2 is just air */ - if (o2 >= 209 && o2 <= 210) { - mix->o2.permille = 0; - return; - } + if (MATCH(".date", divedate, &dive->when)) { + dive->when = utc_mktime(&cur_tm); + return; } - - /* Sane mix? */ - if (o2 <= 1000 && he <= 1000 && o2+he <= 1000) + if (MATCH(".location", utf8_string, &dive->location)) + return; + if (MATCH(".notes", utf8_string, &dive->notes)) return; - fprintf(stderr, "Odd gasmix: %d O2 %d He\n", o2, he); - memset(mix, 0, sizeof(*mix)); + + nonmatch("trip", name, buf); } /* - * There are two ways to give cylinder size information: - * - total amount of gas in cuft (depends on working pressure and physical size) - * - physical size - * - * where "physical size" is the one that actually matters and is sane. - * - * We internally use physical size only. But we save the workingpressure - * so that we can do the conversion if required. + * File boundaries are dive boundaries. But sometimes there are + * multiple dives per file, so there can be other events too that + * trigger a "new dive" marker and you may get some nesting due + * to that. Just ignore nesting levels. */ -static void sanitize_cylinder_type(cylinder_type_t *type) +static void dive_start(void) { - /* If we have no working pressure, it had *better* be just a physical size! */ - if (!type->workingpressure.mbar) + if (cur_dive) return; - - /* - * 35l tanks? Do they exist? - * Assume this is a "size in cuft" thing. - */ - if (type->size.mliter > 35000) { - double volume_of_air = type->size.mliter * 28.317; /* cu ft to milliliter */ - double atm = type->workingpressure.mbar / 1013.25; /* working pressure in atm */ - double volume = volume_of_air / atm; /* milliliters at 1 atm: "true size" */ - type->size.mliter = volume; - } -} - -static void sanitize_cylinder_info(struct dive *dive) -{ - int i; - - for (i = 0; i < MAX_CYLINDERS; i++) { - sanitize_gasmix(&dive->cylinder[i].gasmix); - sanitize_cylinder_type(&dive->cylinder[i].type); - } + cur_dive = alloc_dive(); + memset(&cur_tm, 0, sizeof(cur_tm)); } static void dive_end(void) { - if (!dive) + if (!cur_dive) return; - sanitize_cylinder_info(dive); - record_dive(dive); - dive = NULL; - cylinder_index = 0; + record_dive(cur_dive); + cur_dive = NULL; + cur_cylinder_index = 0; + cur_ws_index = 0; } -static void suunto_start(void) +static void trip_start(void) { - suunto++; - units = SI_units; + if (cur_trip) + return; + cur_trip = alloc_dive(); + memset(&cur_tm, 0, sizeof(cur_tm)); } -static void suunto_end(void) +static void trip_end(void) { - suunto--; + if (!cur_trip) + return; + record_trip(cur_trip); + cur_trip = NULL; } -static void uemis_start(void) +static void event_start(void) { - uemis++; - units = SI_units; + memset(&cur_event, 0, sizeof(cur_event)); + cur_event.active = 1; } -static void uemis_end(void) +static void event_end(void) { + if (cur_event.name && strcmp(cur_event.name, "surface") != 0) + add_event(cur_dive, cur_event.time.seconds, + cur_event.type, cur_event.flags, + cur_event.value, cur_event.name); + cur_event.active = 0; } -static void event_start(void) +static void cylinder_start(void) { } -static void event_end(void) +static void cylinder_end(void) { - event_index++; + cur_cylinder_index++; } -static void cylinder_start(void) +static void ws_start(void) { } -static void cylinder_end(void) +static void ws_end(void) { - cylinder_index++; + cur_ws_index++; } static void sample_start(void) { - int nr; - - if (!dive) - return; - nr = dive->samples; - if (nr >= alloc_samples) { - unsigned int size; - - alloc_samples = (alloc_samples * 3)/2 + 10; - size = dive_size(alloc_samples); - dive = realloc(dive, size); - if (!dive) - return; - } - sample = dive->sample + nr; - memset(sample, 0, sizeof(*sample)); - event_index = 0; + cur_sample = prepare_sample(&cur_dive); } static void sample_end(void) { - if (!dive) + if (!cur_dive) return; - sample = NULL; - dive->samples++; + finish_sample(cur_dive); + cur_sample = NULL; } static void entry(const char *name, int size, const char *raw) @@ -833,12 +1272,20 @@ static void entry(const char *name, int size, const char *raw) return; memcpy(buf, raw, size); buf[size] = 0; - if (sample) { - try_to_fill_sample(sample, name, buf); + if (cur_event.active) { + try_to_fill_event(name, buf); + return; + } + if (cur_sample) { + try_to_fill_sample(cur_sample, name, buf); return; } - if (dive) { - try_to_fill_dive(dive, name, buf); + if (cur_trip) { + try_to_fill_trip(&cur_trip, name, buf); + return; + } + if (cur_dive) { + try_to_fill_dive(&cur_dive, name, buf); return; } } @@ -921,6 +1368,37 @@ static void visit(xmlNode *n) traverse(n->children); } +static void uemis_importer(void) +{ + import_source = UEMIS; + input_units = SI_units; +} + +static void DivingLog_importer(void) +{ + import_source = DIVINGLOG; + + /* + * Diving Log units are really strange. + * + * Temperatures are in C, except in samples, + * when they are in Fahrenheit. Depths are in + * meters, an dpressure is in PSI in the samples, + * but in bar when it comes to working pressure. + * + * Crazy f*%^ morons. + */ + input_units = SI_units; +} + +static void uddf_importer(void) +{ + import_source = UDDF; + input_units = SI_units; + input_units.pressure = PASCAL; + input_units.temperature = KELVIN; +} + /* * I'm sure this could be done as some fancy DTD rules. * It's just not worth the headache. @@ -930,14 +1408,24 @@ static struct nesting { void (*start)(void), (*end)(void); } nesting[] = { { "dive", dive_start, dive_end }, - { "SUUNTO", suunto_start, suunto_end }, + { "Dive", dive_start, dive_end }, + { "trip", trip_start, trip_end }, { "sample", sample_start, sample_end }, + { "waypoint", sample_start, sample_end }, { "SAMPLE", sample_start, sample_end }, { "reading", sample_start, sample_end }, { "event", event_start, event_end }, { "gasmix", cylinder_start, cylinder_end }, { "cylinder", cylinder_start, cylinder_end }, - { "pre_dive", uemis_start, uemis_end }, + { "weightsystem", ws_start, ws_end }, + { "P", sample_start, sample_end }, + + /* Import type recognition */ + { "Divinglog", DivingLog_importer }, + { "pre_dive", uemis_importer }, + { "dives", uemis_importer }, + { "uddf", uddf_importer }, + { NULL, } }; @@ -972,23 +1460,34 @@ static void reset_all(void) * data within one file, we might have to reset it per * dive for that format. */ - units = SI_units; - suunto = 0; - uemis = 0; + input_units = SI_units; + import_source = UNKNOWN; } -void parse_xml_file(const char *filename) +void parse_xml_buffer(const char *url, const char *buffer, int size, GError **error) { xmlDoc *doc; - doc = xmlReadFile(filename, NULL, 0); + doc = xmlReadMemory(buffer, size, url, NULL, 0); if (!doc) { - fprintf(stderr, "Failed to parse '%s'.\n", filename); + fprintf(stderr, "Failed to parse '%s'.\n", url); + if (error != NULL) + { + *error = g_error_new(g_quark_from_string("subsurface"), + DIVE_ERROR_PARSE, + "Failed to parse '%s'", + url); + } return; } - + /* we assume that the last (or only) filename passed as argument is a + * great filename to use as default when saving the dives */ + set_filename(url); reset_all(); dive_start(); +#ifdef XSLT + doc = test_xslt_transforms(doc); +#endif traverse(xmlDocGetRootElement(doc)); dive_end(); xmlFreeDoc(doc); @@ -999,3 +1498,89 @@ void parse_xml_init(void) { LIBXML_TEST_VERSION } + +#ifdef XSLT + +/* Maybe we'll want a environment variable that can override this.. */ +static const char *xslt_path = XSLT ":xslt:."; + +static xsltStylesheetPtr try_get_stylesheet(const char *path, int len, const char *name) +{ + xsltStylesheetPtr ret; + int namelen = strlen(name); + char *filename = malloc(len+1+namelen+1); + + if (!filename) + return NULL; + + memcpy(filename, path, len); + filename[len] = G_DIR_SEPARATOR; + memcpy(filename + len + 1, name, namelen+1); + + ret = NULL; + if (!access(filename, R_OK)) + ret = xsltParseStylesheetFile(filename); + free(filename); + + return ret; +} + +static xsltStylesheetPtr get_stylesheet(const char *name) +{ + const char *path, *next; + + path = getenv("SUBSURFACE_XSLT_PATH"); + if (!path) + path = xslt_path; + + do { + int len; + xsltStylesheetPtr ret; + + next = strchr(path, ':'); + len = strlen(path); + if (next) { + len = next - path; + next++; + } + ret = try_get_stylesheet(path, len, name); + if (ret) + return ret; + } while ((path = next) != NULL); + + return NULL; +} + +static struct xslt_files { + const char *root; + const char *file; +} xslt_files[] = { + { "SUUNTO", "SuuntoSDM.xslt" }, + { "JDiveLog", "jdivelog2subsurface.xslt" }, + { NULL, } +}; + +xmlDoc *test_xslt_transforms(xmlDoc *doc) +{ + struct xslt_files *info = xslt_files; + xmlDoc *transformed; + xsltStylesheetPtr xslt = NULL; + xmlNode *root_element = xmlDocGetRootElement(doc); + + while ((info->root) && (strcasecmp(root_element->name, info->root) != 0)) { + info++; + } + + if (info->root) { + xmlSubstituteEntitiesDefault(1); + xslt = get_stylesheet(info->file); + if (xslt == NULL) + return doc; + transformed = xsltApplyStylesheet(xslt, doc, NULL); + xmlFreeDoc(doc); + xsltFreeStylesheet(xslt); + return transformed; + } + return doc; +} +#endif