X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse.c;h=3ada58b46630e4f93d81508ff54df6db2fef5424;hb=048a5a2b32c0638708ca4779007f9e33226d54f4;hp=414d279284f12bdfd355e0a354afdd48c27ffc74;hpb=edbf68d8055b343d1b608b0d934e7876602b7ff7;p=ext%2Fsubsurface.git diff --git a/parse.c b/parse.c index 414d279..3ada58b 100644 --- a/parse.c +++ b/parse.c @@ -1,10 +1,14 @@ #include #include #include +#include +#include #include #include #include +static int verbose; + /* * Some silly typedefs to make our units very explicit. * @@ -79,6 +83,23 @@ typedef struct { 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; +} + struct sample { duration_t time; depth_t depth; @@ -98,24 +119,74 @@ struct dive { struct sample sample[]; }; +static struct dive **dive_table; +static int nr_dives, nr_allocated; + static void record_dive(struct dive *dive) { - static int nr; + if (nr_dives >= nr_allocated) { + nr_allocated = (nr_dives + 32) * 3 / 2; + dive_table = realloc(dive_table, nr_allocated * sizeof(struct dive *)); + if (!dive_table) + exit(1); + } + dive_table[nr_dives++] = dive; +} + +static void show_dive(int nr, struct dive *dive) +{ + int i; struct tm *tm; tm = gmtime(&dive->when); printf("Dive %d with %d samples at %02d:%02d:%02d %04d-%02d-%02d\n", - ++nr, dive->samples, + nr, dive->samples, tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday); + + if (!verbose) + return; + + 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)); + } +} + +static int sortfn(const void *_a, const void *_b) +{ + const struct dive *a = *(void **)_a; + const struct dive *b = *(void **)_b; + + if (a->when < b->when) + return -1; + if (a->when > b->when) + return 1; + return 0; +} + +static void report_dives(void) +{ + int i; + qsort(dive_table, nr_dives, sizeof(struct dive *), sortfn); + + for (i = 0; i < nr_dives; i++) + show_dive(i+1, dive_table[i]); } static void nonmatch(const char *type, const char *fullname, const char *name, char *buffer) { - printf("Unable to match %s '(%.*s)%s' (%s)\n", type, - (int) (name - fullname), fullname, name, - buffer); + if (verbose > 1) + printf("Unable to match %s '(%.*s)%s' (%s)\n", type, + (int) (name - fullname), fullname, name, + buffer); free(buffer); } @@ -152,6 +223,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) @@ -202,10 +274,184 @@ 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; +}; + +enum number_type { + NEITHER, + INTEGER, + FLOAT +}; + +static enum number_type integer_or_float(char *buffer, union int_or_float *res) +{ + char *end; + long val; + double fp; + + /* Integer or floating point? */ + val = strtol(buffer, &end, 10); + if (val < 0 || end == buffer) + return NEITHER; + + /* Looks like it might be floating point? */ + if (*end == '.') { + errno = 0; + fp = strtod(buffer, &end); + if (!errno) { + res->fp = fp; + return FLOAT; + } + } + + res->i = val; + return INTEGER; +} + +static void pressure(char *buffer, void *_press) +{ + pressure_t *pressure = _press; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case FLOAT: + /* Maybe it's in Bar? */ + if (val.fp < 500.0) { + pressure->mbar = val.fp * 1000; + break; + } + printf("Unknown fractional pressure reading %s\n", buffer); + break; + + case INTEGER: + /* + * Random integer? Maybe in PSI? Or millibar already? + * + * We assume that 5 bar is a ridiculous tank pressure, + * so if it's smaller than 5000, it's in PSI.. + */ + if (val.i < 5000) { + pressure->mbar = val.i * 68.95; + break; + } + pressure->mbar = val.i; + break; + default: + printf("Strange pressure reading %s\n", buffer); + } + free(buffer); +} + +static void depth(char *buffer, void *_depth) +{ + depth_t *depth = _depth; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + /* Integer values are probably in feet */ + case INTEGER: + depth->mm = 304.8 * val.i; + break; + /* Float? Probably meters.. */ + case FLOAT: + depth->mm = val.fp * 1000; + break; + default: + printf("Strange depth reading %s\n", buffer); + } + 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) +{ + duration_t *time = _time; + union int_or_float val; + + switch (integer_or_float(buffer, &val)) { + case INTEGER: + time->seconds = val.i; + break; + default: + printf("Strange sample time reading %s\n", buffer); + } + free(buffer); +} + /* 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); } @@ -218,6 +464,8 @@ 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; nonmatch("dive", name, last, buf); } @@ -273,6 +521,7 @@ static void sample_start(void) return; } sample = dive->sample + nr; + memset(sample, 0, sizeof(*sample)); } static void sample_end(void) @@ -412,13 +661,37 @@ 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) { int i; LIBXML_TEST_VERSION - for (i = 1; i < argc; i++) - parse(argv[i]); + for (i = 1; i < argc; i++) { + const char *a = argv[i]; + + if (a[0] == '-') { + parse_argument(a); + continue; + } + parse(a); + } + report_dives(); return 0; }