X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse.c;h=58d446db099c46f408a3c27d35bdfec99e249d40;hb=feec55504084baf022517d39e72431b4d361a217;hp=06149c31782adf412f89a8e6746fa53cc46c2c92;hpb=716a680920cdd27129c36ea284e44920d0f2d79d;p=ext%2Fsubsurface.git diff --git a/parse.c b/parse.c index 06149c3..58d446d 100644 --- a/parse.c +++ b/parse.c @@ -7,145 +7,35 @@ #include #include -static int verbose; +#include "dive.h" -/* - * Some silly typedefs to make our units very explicit. - * - * Also, the units are chosen so that values can be expressible as - * integers, so that we never have FP rounding issues. And they - * are small enough that converting to/from imperial units doesn't - * really matter. - * - * We also strive to make '0' a meaningless number saying "not - * initialized", since many values are things that may not have - * been reported (eg tank pressure or temperature from dive - * computers that don't support them). But sometimes -1 is an even - * more explicit way of saying "not there". - * - * Thus "millibar" for pressure, for example, or "millikelvin" for - * temperatures. Doing temperatures in celsius or fahrenheit would - * make for loss of precision when converting from one to the other, - * and using millikelvin is SI-like but also means that a temperature - * of '0' is clearly just a missing temperature or tank pressure. - * - * Also strive to use units that can not possibly be mistaken for a - * valid value in a "normal" system without conversion. If the max - * depth of a dive is '20000', you probably didn't convert from mm on - * output, or if the max depth gets reported as "0.2ft" it was either - * a really boring dive, or there was some missing input conversion, - * and a 60-ft dive got recorded as 60mm. - * - * Doing these as "structs containing value" means that we always - * have to explicitly write out those units in order to get at the - * actual value. So there is hopefully little fear of using a value - * in millikelvin as Fahrenheit by mistake. - * - * We don't actually use these all yet, so maybe they'll change, but - * I made a number of types as guidelines. - */ -typedef struct { - int seconds; -} duration_t; - -typedef struct { - int mm; -} depth_t; - -typedef struct { - int mbar; -} pressure_t; - -typedef struct { - int mkelvin; -} temperature_t; - -typedef struct { - int mliter; -} volume_t; - -typedef struct { - int permille; -} fraction_t; - -typedef struct { - int grams; -} weight_t; - -typedef struct { - fraction_t o2; - fraction_t n2; - fraction_t he2; -} gasmix_t; - -typedef struct { - volume_t size; - pressure_t pressure; -} tank_type_t; - -static int to_feet(depth_t depth) -{ - return depth.mm * 0.00328084 + 0.5; -} - -static int to_C(temperature_t temp) -{ - if (!temp.mkelvin) - return 0; - return (temp.mkelvin - 273150) / 1000; -} - -static int to_PSI(pressure_t pressure) -{ - return pressure.mbar * 0.0145037738 + 0.5; -} +int verbose; -struct sample { - duration_t time; - depth_t depth; - temperature_t temperature; - pressure_t tankpressure; - int tankindex; -}; - -struct dive { - time_t when; - depth_t maxdepth, meandepth; - duration_t duration, surfacetime; - depth_t visibility; - temperature_t airtemp, watertemp; - pressure_t beginning_pressure, end_pressure; - int samples; - struct sample sample[]; -}; +struct dive_table dive_table; +/* + * Add a dive into the dive_table array + */ static void record_dive(struct dive *dive) { - int i; - static int nr; - struct tm *tm; + int nr = dive_table.nr, allocated = dive_table.allocated; + struct dive **dives = dive_table.dives; - tm = gmtime(&dive->when); - - printf("Dive %d with %d samples at %02d:%02d:%02d %04d-%02d-%02d\n", - ++nr, dive->samples, - tm->tm_hour, tm->tm_min, tm->tm_sec, - tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday); - for (i = 0; i < dive->samples; i++) { - struct sample *s = dive->sample + i; - - printf("%4d:%02d: %3d ft, %2d C, %4d PSI\n", - s->time.seconds / 60, - s->time.seconds % 60, - to_feet(s->depth), - to_C(s->temperature), - to_PSI(s->tankpressure)); + if (nr >= allocated) { + allocated = (nr + 32) * 3 / 2; + dives = realloc(dives, allocated * sizeof(struct dive *)); + if (!dives) + exit(1); + dive_table.dives = dives; + dive_table.allocated = allocated; } + dives[nr] = dive; + dive_table.nr = nr+1; } static void nonmatch(const char *type, const char *fullname, const char *name, char *buffer) { - if (verbose) + if (verbose > 1) printf("Unable to match %s '(%.*s)%s' (%s)\n", type, (int) (name - fullname), fullname, name, buffer); @@ -185,6 +75,7 @@ static time_t utc_mktime(struct tm *tm) int month = tm->tm_mon; int day = tm->tm_mday; + /* First normalize relative to 1900 */ if (year < 70) year += 100; else if (year > 1900) @@ -235,6 +126,26 @@ static void divetime(char *buffer, void *_when) free(buffer); } +/* Libdivecomputer: "2011-03-20 10:22:38" */ +static void divedatetime(char *buffer, void *_when) +{ + int y,m,d; + int hr,min,sec; + time_t *when = _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); + } + free(buffer); +} + union int_or_float { long i; double fp; @@ -311,11 +222,10 @@ static void depth(char *buffer, void *_depth) union int_or_float val; switch (integer_or_float(buffer, &val)) { - /* Integer values are probably in feet */ + /* All values are probably in meters */ case INTEGER: - depth->mm = 304.8 * val.i; - break; - /* Float? Probably meters.. */ + val.fp = val.i; + /* fallthrough */ case FLOAT: depth->mm = val.fp * 1000; break; @@ -362,12 +272,18 @@ static void temperature(char *buffer, void *_temperature) static void sampletime(char *buffer, void *_time) { + int i; + int min, sec; duration_t *time = _time; - union int_or_float val; - switch (integer_or_float(buffer, &val)) { - case INTEGER: - time->seconds = val.i; + 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); @@ -375,6 +291,15 @@ static void sampletime(char *buffer, void *_time) 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) { @@ -405,6 +330,36 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf) 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); } @@ -435,10 +390,34 @@ 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 " + "(%d ft, %d min)", + 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; } @@ -465,9 +444,18 @@ static void sample_start(void) static void sample_end(void) { - sample = NULL; if (!dive) return; + + if (sample->time.seconds > dive->duration.seconds) { + if (sample->depth.mm) + dive->duration = sample->time; + } + + if (sample->depth.mm > dive->maxdepth.mm) + dive->maxdepth.mm = sample->depth.mm; + + sample = NULL; dive->samples++; } @@ -491,7 +479,6 @@ static void entry(const char *name, int size, const char *raw) static const char *nodename(xmlNode *node, char *buf, int len) { - if (!node || !node->name) return "root"; @@ -583,7 +570,7 @@ static void traverse(xmlNode *node) } } -static void parse(const char *filename) +void parse_xml_file(const char *filename) { xmlDoc *doc; @@ -600,36 +587,7 @@ static void parse(const char *filename) xmlCleanupParser(); } -static void parse_argument(const char *arg) -{ - const char *p = arg+1; - - do { - switch (*p) { - case 'v': - verbose++; - continue; - default: - fprintf(stderr, "Bad argument '%s'\n", arg); - exit(1); - } - } while (*++p); -} - -int main(int argc, char **argv) +void parse_xml_init(void) { - int i; - LIBXML_TEST_VERSION - - for (i = 1; i < argc; i++) { - const char *a = argv[i]; - - if (a[0] == '-') { - parse_argument(a); - continue; - } - parse(a); - } - return 0; }