+ free(buffer);
+}
+
+static void temperature(char *buffer, void *_temperature)
+{
+ temperature_t *temperature = _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) {
+ temperature->mkelvin = (val.fp + 273.16) * 1000;
+ break;
+ }
+ /* Fahrenheit */
+ if (val.fp < 212.0) {
+ 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);
+ }
+ free(buffer);
+}
+
+static void sampletime(char *buffer, void *_time)
+{
+ int i;
+ int min, sec;
+ duration_t *time = _time;
+
+ i = sscanf(buffer, "%d:%d", &min, &sec);
+ switch (i) {
+ case 1:
+ sec = min;
+ min = 0;
+ /* fallthrough */
+ case 2:
+ time->seconds = sec + min*60;
+ break;
+ default:
+ printf("Strange sample time reading %s\n", buffer);
+ }
+ free(buffer);
+}
+
+static void duration(char *buffer, void *_time)
+{
+ sampletime(buffer, _time);
+}
+
+static void ignore(char *buffer, void *_time)
+{
+}
+
+/* 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)
+{
+ const char *last = last_part(name);
+
+ if (match("pressure", last, pressure, buf, &sample->tankpressure))
+ return;
+ if (match("cylpress", last, pressure, buf, &sample->tankpressure))
+ return;
+ if (match("depth", last, depth, buf, &sample->depth))
+ return;
+ if (match("temperature", last, temperature, buf, &sample->temperature))
+ return;
+ if (match("sampletime", last, sampletime, buf, &sample->time))
+ return;
+ if (match("time", last, sampletime, buf, &sample->time))
+ return;
+
+ nonmatch("sample", name, last, buf);
+}
+
+/* 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)
+{
+ const char *last = last_part(name);
+
+ if (match("date", last, divedate, buf, &dive->when))
+ return;
+ if (match("time", last, divetime, buf, &dive->when))
+ return;
+ if (match("datetime", last, divedatetime, buf, &dive->when))
+ return;
+ if (match("maxdepth", last, depth, buf, &dive->maxdepth))
+ return;
+ if (match("meandepth", last, depth, buf, &dive->meandepth))
+ return;
+ if (match("divetime", last, duration, buf, &dive->duration))
+ return;
+ if (match("divetimesec", last, duration, buf, &dive->duration))
+ return;
+ if (match("surfacetime", last, duration, buf, &dive->surfacetime))
+ return;
+ if (match("airtemp", last, temperature, buf, &dive->airtemp))
+ return;
+ if (match("watertemp", last, temperature, buf, &dive->watertemp))
+ return;
+ if (match("cylinderstartpressure", last, pressure, buf, &dive->beginning_pressure))
+ return;
+ if (match("cylinderendpressure", last, pressure, buf, &dive->end_pressure))
+ return;
+ if (match("divenumber", last, ignore, buf, NULL))
+ return;
+ if (match("diveseries", last, ignore, buf, NULL))
+ return;
+ if (match("number", last, ignore, buf, NULL))
+ return;
+ if (match("size", last, ignore, buf, NULL))
+ return;
+ if (match("fingerprint", last, ignore, buf, NULL))
+ return;
+ nonmatch("dive", name, last, buf);
+}
+
+static unsigned int dive_size(int samples)
+{
+ return sizeof(struct dive) + samples*sizeof(struct sample);
+}
+
+/*
+ * 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)
+{
+ 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));
+}
+
+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 "
+ "(%d ft, %d min)\n",
+ tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec,
+ to_feet(dive->maxdepth), dive->duration.seconds / 60);
+ p = malloc(len+1);
+ if (!p)
+ exit(1);
+ memcpy(p, buffer, len+1);
+ return p;
+}
+
+static void dive_end(void)
+{
+ if (!dive)
+ return;
+ if (!dive->name)
+ dive->name = generate_name(dive);
+ record_dive(dive);
+ dive = NULL;
+}
+
+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));
+}
+
+static void sample_end(void)
+{
+ sample = NULL;
+ if (!dive)
+ return;
+ dive->samples++;
+}
+
+static void entry(const char *name, int size, const char *raw)
+{
+ char *buf = malloc(size+1);
+
+ if (!buf)
+ return;
+ memcpy(buf, raw, size);
+ buf[size] = 0;
+ if (sample) {
+ try_to_fill_sample(sample, name, buf);
+ return;
+ }
+ if (dive) {
+ try_to_fill_dive(dive, name, buf);
+ return;
+ }
+}
+
+static const char *nodename(xmlNode *node, char *buf, int len)
+{
+ if (!node || !node->name)
+ return "root";