X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse-xml.c;h=6a08a3845c9551c3f35b818ff5c51b468537abda;hb=254b851e44a31e2028a2fdddfb4f6989a8e59374;hp=14c21972cdce96bc050606e2f65a9d0d8b49554a;hpb=61d0aa10e1a88ac2e5ddcab9e0f05a729b3ab9e9;p=ext%2Fsubsurface.git diff --git a/parse-xml.c b/parse-xml.c index 14c2197..6a08a38 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -3,11 +3,13 @@ #include #include #include +#define __USE_XOPEN #include #include #include #include "dive.h" +#include "uemis.h" int verbose; @@ -16,7 +18,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; @@ -90,11 +92,16 @@ const struct units IMPERIAL_units = { /* * Dive info as it is being built up.. */ -static int alloc_samples; static struct dive *dive; static struct sample *sample; +static struct { + int active; + duration_t time; + int type, flags, value; + const char *name; +} event; static struct tm tm; -static int event_index, cylinder_index; +static int cylinder_index; static enum import_source { UNKNOWN, @@ -105,7 +112,7 @@ static enum import_source { UDDF, } import_source; -static time_t utc_mktime(struct tm *tm) +time_t utc_mktime(struct tm *tm) { static const int mdays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 @@ -423,7 +430,7 @@ static void water_pressure(char *buffer, void *_depth) * 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; @@ -488,6 +495,16 @@ static int uemis_fill_sample(struct sample *sample, const char *name, int len, c * 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) { @@ -496,6 +513,9 @@ static void fahrenheit(char *buffer, void *_temperature) 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: @@ -509,7 +529,7 @@ static void fahrenheit(char *buffer, void *_temperature) * pressures are in PSI. But the tank working pressure is in * bar. WTF^2? * - * Crazy stuff like this is why diveclog has everything in + * 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. @@ -546,6 +566,34 @@ static int uddf_fill_sample(struct sample *sample, const char *name, int len, ch 0; } +static void eventtime(char *buffer, void *_duration) +{ + duration_t *duration = _duration; + sampletime(buffer, duration); + if (sample) + duration->seconds += 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, &event.name)) + return; + if (MATCH(".name", utf8_string, &event.name)) + return; + if (MATCH(".time", eventtime, &event.time)) + return; + if (MATCH(".type", get_index, &event.type)) + return; + if (MATCH(".flags", get_index, &event.flags)) + return; + if (MATCH(".value", get_index, &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) { @@ -593,8 +641,10 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu /* * 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) +static int suunto_dive_match(struct dive **divep, const char *name, int len, char *buf) { + struct dive *dive = *divep; + 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) || @@ -632,15 +682,17 @@ static void divinglog_place(char *place, void *_location) country = NULL; } -static int divinglog_dive_match(struct dive *dive, const char *name, int len, char *buf) +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(".tanktype", utf8_string, &dive->cylinder[0].type.description) || 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) || @@ -724,6 +776,21 @@ static void uemis_time_zone(char *buffer, void *_when) #endif } +static void uemis_ts(char *buffer, void *_when) +{ + struct tm tm; + time_t *when = _when; + + strptime(buffer, "%Y-%m-%dT%H:%M:%S", &tm); + *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; @@ -788,8 +855,10 @@ static void uemis_percent(char *buffer, void *_cylinder) percent(buffer, &dive->cylinder[index].gasmix.o2); } -static int uemis_dive_match(struct dive *dive, const char *name, int len, char *buf) +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) || @@ -815,6 +884,9 @@ static int uemis_dive_match(struct dive *dive, const char *name, int len, char * 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; } @@ -862,16 +934,32 @@ success: free(buffer); } -static int uddf_dive_match(struct dive *dive, const char *name, int len, char *buf) +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); @@ -879,22 +967,22 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) switch (import_source) { case SUUNTO: - if (suunto_dive_match(dive, name, len, buf)) + if (suunto_dive_match(divep, name, len, buf)) return; break; case UEMIS: - if (uemis_dive_match(dive, name, len, buf)) + if (uemis_dive_match(divep, name, len, buf)) return; break; case DIVINGLOG: - if (divinglog_dive_match(dive, name, len, buf)) + if (divinglog_dive_match(divep, name, len, buf)) return; break; case UDDF: - if (uddf_dive_match(dive, name, len, buf)) + if (uddf_dive_match(divep, name, len, buf)) return; break; @@ -902,6 +990,8 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) break; } + struct dive *dive = *divep; + if (MATCH(".number", get_index, &dive->number)) return; if (MATCH(".date", divedate, &dive->when)) @@ -938,10 +1028,16 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) return; 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(".notes", utf8_string, &dive->notes)) return; + if (MATCH(".divemaster", utf8_string, &dive->divemaster)) + return; + if (MATCH(".buddy", utf8_string, &dive->buddy)) + return; if (MATCH(".cylinder.size", cylindersize, &dive->cylinder[cylinder_index].type.size)) return; @@ -972,21 +1068,13 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) */ static void dive_start(void) { - 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); + dive = alloc_dive(); memset(&tm, 0, sizeof(tm)); } -static void sanitize_gasmix(gasmix_t *mix) +static void sanitize_gasmix(struct gasmix *mix) { unsigned int o2, he; @@ -1017,7 +1105,8 @@ static void sanitize_gasmix(gasmix_t *mix) */ static void match_standard_cylinder(cylinder_type_t *type) { - int psi, cuft, len; + double cuft; + int psi, len; const char *fmt; char buffer[20], *p; @@ -1025,7 +1114,8 @@ static void match_standard_cylinder(cylinder_type_t *type) if (type->description) return; - cuft = type->size.mliter / 1000; + cuft = type->size.mliter / 28317.0; + cuft *= to_ATM(type->workingpressure); psi = type->workingpressure.mbar / 68.95; switch (psi) { @@ -1033,7 +1123,7 @@ static void match_standard_cylinder(cylinder_type_t *type) fmt = "LP%d"; break; case 2600 ... 2700: /* 2640 psi: LP+10% */ - fmt = "LP%d+"; + fmt = "LP%d"; break; case 2900 ... 3100: /* 3000 psi: ALx tank */ fmt = "AL%d"; @@ -1047,7 +1137,7 @@ static void match_standard_cylinder(cylinder_type_t *type) default: return; } - len = snprintf(buffer, sizeof(buffer), fmt, cuft); + len = snprintf(buffer, sizeof(buffer), fmt, (int) (cuft+0.5)); p = malloc(len+1); if (!p) return; @@ -1078,15 +1168,15 @@ static void sanitize_cylinder_type(cylinder_type_t *type) if (!type->size.mliter) return; - /* Ok, we have both size and pressure: try to match a description */ - match_standard_cylinder(type); - if (input_units.volume == CUFT || import_source == SUUNTO) { volume_of_air = type->size.mliter * 28.317; /* milli-cu ft to milliliter */ - atm = type->workingpressure.mbar / 1013.25; /* working pressure in atm */ + atm = to_ATM(type->workingpressure); /* working pressure in atm */ volume = volume_of_air / atm; /* milliliters at 1 atm: "true size" */ type->size.mliter = volume + 0.5; } + + /* Ok, we have both size and pressure: try to match a description */ + match_standard_cylinder(type); } static void sanitize_cylinder_info(struct dive *dive) @@ -1111,11 +1201,15 @@ static void dive_end(void) static void event_start(void) { + memset(&event, 0, sizeof(event)); + event.active = 1; } static void event_end(void) { - event_index++; + if (event.name && strcmp(event.name, "surface") != 0) + add_event(dive, event.time.seconds, event.type, event.flags, event.value, event.name); + event.active = 0; } static void cylinder_start(void) @@ -1129,23 +1223,7 @@ static void cylinder_end(void) 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; + sample = prepare_sample(&dive); } static void sample_end(void) @@ -1153,8 +1231,8 @@ static void sample_end(void) if (!dive) return; + finish_sample(dive, sample); sample = NULL; - dive->samples++; } static void entry(const char *name, int size, const char *raw) @@ -1165,12 +1243,16 @@ static void entry(const char *name, int size, const char *raw) return; memcpy(buf, raw, size); buf[size] = 0; + if (event.active) { + try_to_fill_event(name, buf); + return; + } if (sample) { try_to_fill_sample(sample, name, buf); return; } if (dive) { - try_to_fill_dive(dive, name, buf); + try_to_fill_dive(&dive, name, buf); return; } } @@ -1313,6 +1395,7 @@ static struct nesting { { "SUUNTO", suunto_importer }, { "Divinglog", DivingLog_importer }, { "pre_dive", uemis_importer }, + { "dives", uemis_importer }, { "uddf", uddf_importer }, { NULL, } @@ -1362,14 +1445,16 @@ void parse_xml_file(const char *filename, GError **error) fprintf(stderr, "Failed to parse '%s'.\n", filename); if (error != NULL) { - *error = g_error_new(g_quark_from_string("divelog"), + *error = g_error_new(g_quark_from_string("subsurface"), DIVE_ERROR_PARSE, "Failed to parse '%s'", filename); } 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(filename); reset_all(); dive_start(); traverse(xmlDocGetRootElement(doc));