X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=parse.c;h=52609a636c67e0205f8afe13a0924b1dfcca3381;hb=f46e9f571e92156cd764d6711cac671c053260a1;hp=78d84a4f4c4b2650dbc6036e4d5314a3a433d461;hpb=e1a939ac626dda5cf97122cb650c553b2d1fcb2a;p=ext%2Fsubsurface.git diff --git a/parse.c b/parse.c index 78d84a4..52609a6 100644 --- a/parse.c +++ b/parse.c @@ -1,9 +1,14 @@ #include #include #include +#include +#include +#include #include #include +static int verbose; + /* * Some silly typedefs to make our units very explicit. * @@ -78,6 +83,21 @@ 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) +{ + return (temp.mkelvin + 272150) / 1000; +} + +static int to_PSI(pressure_t pressure) +{ + return pressure.mbar * 0.0145037738 + 0.5; +} + struct sample { duration_t time; depth_t depth; @@ -99,16 +119,35 @@ struct dive { static void record_dive(struct dive *dive) { + int i; static int nr; - - printf("Recording dive %d with %d samples\n", ++nr, dive->samples); + struct tm *tm; + + 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)); + } } -static void nonmatch(const char *type, const char *fullname, const char *name, int size, const char *buffer) +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, - size, buffer); + if (verbose) + printf("Unable to match %s '(%.*s)%s' (%s)\n", type, + (int) (name - fullname), fullname, name, + buffer); + free(buffer); } static const char *last_part(const char *name) @@ -117,18 +156,14 @@ static const char *last_part(const char *name) return p ? p+1 : name; } -/* 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, int size, const char *buffer) -{ - const char *last = last_part(name); - nonmatch("sample", name, last, size, buffer); -} +typedef void (*matchfn_t)(char *buffer, void *); -/* 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, int size, const char *buffer) +static int match(const char *pattern, const char *name, matchfn_t fn, char *buf, void *data) { - const char *last = last_part(name); - nonmatch("dive", name, last, size, buffer); + if (strcasecmp(pattern, name)) + return 0; + fn(buf, data); + return 1; } /* @@ -137,6 +172,239 @@ static void try_to_fill_dive(struct dive *dive, const char *name, int size, cons static int alloc_samples; static struct dive *dive; static struct sample *sample; +static struct tm tm; + +static time_t utc_mktime(struct tm *tm) +{ + static const int mdays[] = { + 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 + }; + int year = tm->tm_year; + int month = tm->tm_mon; + int day = tm->tm_mday; + + if (year < 70) + year += 100; + else if (year > 1900) + year -= 1900; + + /* Normalized to Jan 1, 1970: unix time */ + year -= 70; + + if (year < 0 || year > 129) /* algo only works for 1970-2099 */ + return -1; + if (month < 0 || month > 11) /* array bounds */ + return -1; + if (month < 2 || (year + 2) % 4) + day--; + if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_sec < 0) + return -1; + return (year * 365 + (year + 1) / 4 + mdays[month] + day) * 24*60*60UL + + tm->tm_hour * 60*60 + tm->tm_min * 60 + tm->tm_sec; +} + +static void divedate(char *buffer, void *_when) +{ + int d,m,y; + time_t *when = _when; + + if (sscanf(buffer, "%d.%d.%d", &d, &m, &y) == 3) { + tm.tm_year = y; + tm.tm_mon = m-1; + tm.tm_mday = d; + if (tm.tm_sec | tm.tm_min | tm.tm_hour) + *when = utc_mktime(&tm); + } + free(buffer); +} + +static void divetime(char *buffer, void *_when) +{ + int h,m,s = 0; + time_t *when = _when; + + if (sscanf(buffer, "%d:%d:%d", &h, &m, &s) >= 2) { + tm.tm_hour = h; + tm.tm_min = m; + tm.tm_sec = s; + if (tm.tm_year) + *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); +} + +/* 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; + nonmatch("dive", name, last, buf); +} static unsigned int dive_size(int samples) { @@ -153,12 +421,16 @@ 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 void dive_end(void) @@ -186,6 +458,7 @@ static void sample_start(void) return; } sample = dive->sample + nr; + memset(sample, 0, sizeof(*sample)); } static void sample_end(void) @@ -196,14 +469,20 @@ static void sample_end(void) dive->samples++; } -static void entry(const char *name, int size, const char *buffer) +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, size, buffer); + try_to_fill_sample(sample, name, buf); return; } if (dive) { - try_to_fill_dive(dive, name, size, buffer); + try_to_fill_dive(dive, name, buf); return; } } @@ -319,13 +598,36 @@ 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); + } return 0; }