Don't report dives as they are parsed: sort them at the end and report them then

[ext/subsurface.git] / parse.c

diff --git a/parse.c b/parse.c
index 67aa5a0c23a935af3fa3fdc9b0904e29435da28f..3ada58b46630e4f93d81508ff54df6db2fef5424 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -7,6 +7,8 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
+static int verbose;
+
 /*
  * Some silly typedefs to make our units very explicit.
  *
@@ -81,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;
@@ -100,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);
 }
 
@@ -154,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)
@@ -204,6 +274,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;
@@ -335,9 +425,8 @@ static void sampletime(char *buffer, void *_time)
        union int_or_float val;
 
        switch (integer_or_float(buffer, &val)) {
-       /* C or F? Who knows? Let's default to Celsius */
        case INTEGER:
-               time->seconds = val.i * 1000;
+               time->seconds = val.i;
                break;
        default:
                printf("Strange sample time reading %s\n", buffer);
@@ -375,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);
 }
 
@@ -570,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;
 }