X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse-xml.c;h=36db7e74453dcd8b6f1f4796daab1df6ae51c367;hb=0e3bbd4102ec4d355637b2b8a72a1c16012ec0bc;hp=a2c685ed523ed39b2b9b692f92760d175e4a61a3;hpb=31123f63af0a2b6a9756b8496f56359d1c68a645;p=ext%2Fsubsurface.git diff --git a/parse-xml.c b/parse-xml.c index a2c685e..36db7e7 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -91,9 +91,16 @@ 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 enum import_source { + UNKNOWN, + LIBDIVECOMPUTER, + SUUNTO, + UEMIS, + DIVINGLOG, +} import_source; + static time_t utc_mktime(struct tm *tm) { static const int mdays[] = { @@ -467,6 +474,35 @@ 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? + */ +static void fahrenheit(char *buffer, void *_temperature) +{ + temperature_t *temperature = _temperature; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + temperature->mkelvin = (val.fp + 459.67) * 5000/9; + break; + default: + fprintf(stderr, "Crazy Diving Log temperature 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", pressure, &sample->cylinderpressure) || + 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) { @@ -488,9 +524,19 @@ 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; + + default: + break; } nonmatch("sample", name, buf); @@ -514,6 +560,44 @@ static int suunto_dive_match(struct dive *dive, const char *name, int len, char 0; } +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 *dive, const char *name, int len, char *buf) +{ + 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(".tanktype", utf8_string, &dive->cylinder[0].type.description) || + MATCH(".comments", utf8_string, &dive->notes) || + MATCH(".country.name", utf8_string, &country) || + MATCH(".city.name", utf8_string, &city) || + MATCH(".place.name", divinglog_place, &dive->location) || + 0; +} + static int buffer_value(char *buffer) { int val = atoi(buffer); @@ -564,7 +648,7 @@ static void uemis_date_time(char *buffer, void *_when) switch (integer_or_float(buffer, &val)) { case FLOAT: - *when = (val.fp - 40587.5) * 86400; + *when = (val.fp - 40587) * 86400; break; default: fprintf(stderr, "Strange julian date: %s", buffer); @@ -581,10 +665,78 @@ 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 +} + +/* 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 - 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, &dive->cylinder[index].type.size); +} + +static void uemis_percent(char *buffer, void *_cylinder) +{ + int index = uemis_cylinder_index(_cylinder); + if (index >= 0) + percent(buffer, &dive->cylinder[index].gasmix.o2); } static int uemis_dive_match(struct dive *dive, const char *name, int len, char *buf) @@ -599,6 +751,21 @@ static int uemis_dive_match(struct dive *dive, const char *name, int len, char * 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) || 0; } @@ -608,6 +775,27 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) int len = strlen(name); start_match("dive", name, buf); + + switch (import_source) { + case SUUNTO: + if (suunto_dive_match(dive, name, len, buf)) + return; + break; + + case UEMIS: + if (uemis_dive_match(dive, name, len, buf)) + return; + break; + + case DIVINGLOG: + if (divinglog_dive_match(dive, name, len, buf)) + return; + break; + + default: + break; + } + if (MATCH(".date", divedate, &dive->when)) return; if (MATCH(".time", divetime, &dive->when)) @@ -618,6 +806,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,9 +822,13 @@ 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(".cylinderendpressure", pressure, &dive->end_pressure)) + if (MATCH(".temperature.water", temperature, &dive->watertemp)) + return; + if (MATCH(".cylinderstartpressure", pressure, &dive->cylinder[0].start)) + return; + if (MATCH(".cylinderendpressure", pressure, &dive->cylinder[0].end)) return; if (MATCH(".location", utf8_string, &dive->location)) return; @@ -643,6 +839,12 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) return; if (MATCH(".cylinder.workpressure", pressure, &dive->cylinder[cylinder_index].type.workingpressure)) return; + if (MATCH(".cylinder.description", utf8_string, &dive->cylinder[cylinder_index].type.description)) + return; + if (MATCH(".cylinder.start", pressure, &dive->cylinder[cylinder_index].start)) + return; + if (MATCH(".cylinder.end", pressure, &dive->cylinder[cylinder_index].end)) + return; if (MATCH(".o2", gasmix, &dive->cylinder[cylinder_index].gasmix.o2)) return; @@ -651,13 +853,6 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) if (MATCH(".he", gasmix, &dive->cylinder[cylinder_index].gasmix.he)) return; - /* Suunto XML files are some crazy sh*t. */ - if (suunto && suunto_dive_match(dive, name, len, buf)) - return; - - if (uemis && uemis_dive_match(dive, name, len, buf)) - return; - nonmatch("dive", name, buf); } @@ -683,26 +878,6 @@ static void dive_start(void) memset(&tm, 0, sizeof(tm)); } -static char *generate_name(struct dive *dive) -{ - int len; - struct tm *tm; - char buffer[256], *p; - - tm = gmtime(&dive->when); - - len = snprintf(buffer, sizeof(buffer), - "%04d-%02d-%02d " - "%02d:%02d:%02d", - tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, - tm->tm_hour, tm->tm_min, tm->tm_sec); - p = malloc(len+1); - if (!p) - exit(1); - memcpy(p, buffer, len+1); - return p; -} - static void sanitize_gasmix(gasmix_t *mix) { unsigned int o2, he; @@ -728,6 +903,51 @@ static void sanitize_gasmix(gasmix_t *mix) memset(mix, 0, sizeof(*mix)); } +/* + * See if the size/workingpressure looks like some standard cylinder + * size, eg "AL80". + */ +static void match_standard_cylinder(cylinder_type_t *type) +{ + int psi, cuft, len; + const char *fmt; + char buffer[20], *p; + + /* Do we already have a cylinder description? */ + if (type->description) + return; + + cuft = type->size.mliter / 1000; + psi = type->workingpressure.mbar / 68.95; + + switch (psi) { + case 2300 ... 2500: /* 2400 psi: LP tank */ + fmt = "LP%d"; + break; + case 2600 ... 2700: /* 2640 psi: LP+10% */ + fmt = "LP%d+"; + break; + case 2900 ... 3100: /* 3000 psi: ALx tank */ + fmt = "AL%d"; + break; + case 3400 ... 3500: /* 3442 psi: HP tank */ + fmt = "HP%d"; + break; + case 3700 ... 3850: /* HP+10% */ + fmt = "HP%d+"; + break; + default: + return; + } + len = snprintf(buffer, sizeof(buffer), fmt, cuft); + p = malloc(len+1); + if (!p) + return; + memcpy(p, buffer, len+1); + type->description = p; +} + + /* * There are two ways to give cylinder size information: * - total amount of gas in cuft (depends on working pressure and physical size) @@ -740,20 +960,24 @@ static void sanitize_gasmix(gasmix_t *mix) */ static void sanitize_cylinder_type(cylinder_type_t *type) { + double volume_of_air, atm, volume; + /* If we have no working pressure, it had *better* be just a physical size! */ if (!type->workingpressure.mbar) 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; - } + /* No size either? Nothing to go on */ + if (!type->size.mliter) + return; + + /* Ok, we have both size and pressure: try to match a description */ + match_standard_cylinder(type); + + /* .. and let's assume that the 'size' was cu ft of air */ + volume_of_air = type->size.mliter * 28.317; /* milli-cu ft to milliliter */ + atm = type->workingpressure.mbar / 1013.25; /* working pressure in atm */ + volume = volume_of_air / atm; /* milliliters at 1 atm: "true size" */ + type->size.mliter = volume + 0.5; } static void sanitize_cylinder_info(struct dive *dive) @@ -770,35 +994,12 @@ static void dive_end(void) { if (!dive) return; - if (!dive->name) - dive->name = generate_name(dive); sanitize_cylinder_info(dive); record_dive(dive); dive = NULL; cylinder_index = 0; } -static void suunto_start(void) -{ - suunto++; - units = SI_units; -} - -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) { } @@ -943,6 +1144,33 @@ static void visit(xmlNode *n) traverse(n->children); } +static void suunto_importer(void) +{ + import_source = SUUNTO; + units = SI_units; +} + +static void uemis_importer(void) +{ + import_source = UEMIS; + 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, but pressure is in PSI. + */ + units = SI_units; + units.pressure = PSI; +} + /* * I'm sure this could be done as some fancy DTD rules. * It's just not worth the headache. @@ -952,14 +1180,20 @@ static struct nesting { void (*start)(void), (*end)(void); } nesting[] = { { "dive", dive_start, dive_end }, - { "SUUNTO", suunto_start, suunto_end }, + { "Dive", dive_start, dive_end }, { "sample", 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 }, + { "P", sample_start, sample_end }, + + /* Import type recognition */ + { "SUUNTO", suunto_importer }, + { "Divinglog", DivingLog_importer }, + { "pre_dive", uemis_importer }, + { NULL, } }; @@ -995,17 +1229,23 @@ static void reset_all(void) * dive for that format. */ units = SI_units; - suunto = 0; - uemis = 0; + import_source = UNKNOWN; } -void parse_xml_file(const char *filename) +void parse_xml_file(const char *filename, GError **error) { xmlDoc *doc; doc = xmlReadFile(filename, NULL, 0); if (!doc) { fprintf(stderr, "Failed to parse '%s'.\n", filename); + if (error != NULL) + { + *error = g_error_new(g_quark_from_string("divelog"), + DIVE_ERROR_PARSE, + "Failed to parse '%s'", + filename); + } return; }