X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse-xml.c;h=bc4d4c54661aeb1db4d2462e49625ce8b5997174;hb=2b0f30c3d4773d4e78daf7e2ce76f5c3f3a2d0b3;hp=14c21972cdce96bc050606e2f65a9d0d8b49554a;hpb=61d0aa10e1a88ac2e5ddcab9e0f05a729b3ab9e9;p=ext%2Fsubsurface.git diff --git a/parse-xml.c b/parse-xml.c index 14c2197..bc4d4c5 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; @@ -90,11 +96,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 +116,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 @@ -418,12 +429,12 @@ static void water_pressure(char *buffer, void *_depth) 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; @@ -488,6 +499,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 +517,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 +533,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 +570,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) { @@ -556,6 +608,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)) @@ -593,8 +647,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 +688,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 +782,27 @@ 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; + + 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; @@ -788,8 +867,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 +896,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 +946,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 +979,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 +1002,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 +1040,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 +1080,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 +1117,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,15 +1126,16 @@ static void match_standard_cylinder(cylinder_type_t *type) if (type->description) return; - cuft = type->size.mliter / 1000; - psi = type->workingpressure.mbar / 68.95; + cuft = ml_to_cuft(type->size.mliter); + cuft *= to_ATM(type->workingpressure); + psi = to_PSI(type->workingpressure); switch (psi) { case 2300 ... 2500: /* 2400 psi: LP tank */ 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 +1149,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 +1180,16 @@ 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 */ + /* confusing - we don't really start from ml but millicuft !*/ + volume_of_air = cuft_to_l(type->size.mliter); + 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 +1214,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 +1236,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 +1244,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 +1256,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 +1408,7 @@ static struct nesting { { "SUUNTO", suunto_importer }, { "Divinglog", DivingLog_importer }, { "pre_dive", uemis_importer }, + { "dives", uemis_importer }, { "uddf", uddf_importer }, { NULL, } @@ -1362,16 +1458,21 @@ 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(); +#ifdef XSLT + doc = test_xslt_transforms(doc); +#endif traverse(xmlDocGetRootElement(doc)); dive_end(); xmlFreeDoc(doc); @@ -1382,3 +1483,70 @@ 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 = xslt_path, *next; + + 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; +} + +xmlDoc *test_xslt_transforms(xmlDoc *doc) +{ + xmlDoc *transformed; + xsltStylesheetPtr xslt = NULL; + xmlNode *root_element = xmlDocGetRootElement(doc); + if (strcasecmp(root_element->name, "JDiveLog") == 0) { + xmlSubstituteEntitiesDefault(1); + xslt = get_stylesheet("jdivelog2subsurface.xslt"); + if (xslt == NULL) + return doc; + transformed = xsltApplyStylesheet(xslt, doc, NULL); + xmlFreeDoc(doc); + xsltFreeStylesheet(xslt); + return transformed; + } + return doc; +} +#endif