mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/import-suunto.c

593 lines
17 KiB
C
Raw Normal View History

Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
// SPDX-License-Identifier: GPL-2.0
#ifdef __clang__
// Clang has a bug on zero-initialization of C structs.
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#endif
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
#include "ssrf.h"
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
#include "dive.h"
Core: introduce new subsurface-string header First small step to shrinking dive.h. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-05-11 08:25:41 -07:00
#include "subsurface-string.h"
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
#include "parse.h"
#include "divelist.h"
#include "device.h"
#include "membuffer.h"
#include "gettext.h"
Cleanup: move tag functions into own translation unit Make dive.h a bit slimmer. It's only a drop in the bucket - but at least when modifying tag functions not the *whole* application is rebuilt anymore. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-05-30 18:29:36 +02:00
#include "tag.h"
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm4_events(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
event_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[1])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_event.time.seconds = atoi(data[1]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[2]) {
switch (atoi(data[2])) {
case 1:
/* 1 Mandatory Safety Stop */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "safety stop (mandatory)");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 3:
/* 3 Deco */
/* What is Subsurface's term for going to
* deco? */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "deco");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 4:
/* 4 Ascent warning */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "ascent");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 5:
/* 5 Ceiling broken */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "violation");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 6:
/* 6 Mandatory safety stop ceiling error */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "violation");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 7:
/* 7 Below deco floor */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "below floor");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 8:
/* 8 Dive time alarm */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "divetime");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 9:
/* 9 Depth alarm */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "maxdepth");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 10:
/* 10 OLF 80% */
case 11:
/* 11 OLF 100% */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "OLF");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 12:
/* 12 High pO₂ */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "PO2");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 13:
/* 13 Air time */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "airtime");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 17:
/* 17 Ascent warning */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "ascent");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 18:
/* 18 Ceiling error */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "ceiling");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 19:
/* 19 Surfaced */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "surface");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 20:
/* 20 Deco */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "deco");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 22:
case 32:
/* 22 Mandatory safety stop violation */
/* 32 Deep stop violation */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "violation");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 30:
/* Tissue level warning */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "tissue warning");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 37:
/* Tank pressure alarm */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "tank pressure");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 257:
/* 257 Dive active */
/* This seems to be given after surface when
* descending again. */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "surface");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 258:
/* 258 Bookmark */
if (data[3]) {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "heading");
state->cur_event.value = atoi(data[3]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
} else {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "bookmark");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
break;
case 259:
/* Deep stop */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "Deep stop");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 260:
/* Deep stop */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "Deep stop cleared");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 266:
/* Mandatory safety stop activated */
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "safety stop (mandatory)");
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
case 267:
/* Mandatory safety stop deactivated */
/* DM5 shows this only on event list, not on the
* profile so skipping as well for now */
break;
default:
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "unknown");
state->cur_event.value = atoi(data[2]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
break;
}
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
event_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
return 0;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm4_tags(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
taglist_add_tag(&state->cur_dive->tag_list, data[0]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
return 0;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm4_dive(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Cleanup: durations are now signed Somehow a whitespace fix snuck in here. Oops. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-12-17 09:12:08 -08:00
int i;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
int interval, retval = 0;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
sqlite3 *handle = state->sql_handle;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
float *profileBlob;
unsigned char *tempBlob;
int *pressureBlob;
char get_events_template[] = "select * from Mark where DiveId = %d";
char get_tags_template[] = "select Text from DiveTag where DiveId = %d";
char get_events[64];
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cylinder_t *cyl;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
dive_start(state);
state->cur_dive->number = atoi(data[0]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->when = (time_t)(atol(data[1]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[2])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[2], &state->cur_dive->notes);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
* DM4 stores Duration and DiveTime. It looks like DiveTime is
* 10 to 60 seconds shorter than Duration. However, I have no
* idea what is the difference and which one should be used.
* Duration = data[3]
* DiveTime = data[15]
*/
if (data[3])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->duration.seconds = atoi(data[3]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[15])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.duration.seconds = atoi(data[15]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
* TODO: the deviceid hash should be calculated here.
*/
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
settings_start(state);
dc_settings_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[4])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[4], &state->cur_settings.dc.serial_nr);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[5])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[5], &state->cur_settings.dc.model);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_settings.dc.deviceid = 0xffffffff;
dc_settings_end(state);
settings_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[6])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.maxdepth.mm = lrint(strtod_flags(data[6], NULL, 0) * 1000);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[8])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[9])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.watertemp.mkelvin = C_to_mkelvin(atoi(data[9]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
* TODO: handle multiple cylinders
*/
Cleanup: return cylinder from cylinder_start() in parser Most callers of this function accessed the newly generated cylinder immediately after calling this function. Thus, for convenience, return the added cylinder. This avoids a number of verbose expressions. On the flip side, cylinder_start() now has to be cast to function returning void in a the "nesting" function table. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:59:14 +02:00
cyl = cylinder_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[22] && atoi(data[22]) > 0)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->start.mbar = atoi(data[22]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
else if (data[10] && atoi(data[10]) > 0)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->start.mbar = atoi(data[10]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[23] && atoi(data[23]) > 0)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->end.mbar = (atoi(data[23]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[11] && atoi(data[11]) > 0)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->end.mbar = (atoi(data[11]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[12])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->type.size.mliter = lrint((strtod_flags(data[12], NULL, 0)) * 1000);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[13])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->type.workingpressure.mbar = (atoi(data[13]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[20])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->gasmix.o2.permille = atoi(data[20]) * 10;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[21])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->gasmix.he.permille = atoi(data[21]) * 10;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
cylinder_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[14])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.surface_pressure.mbar = (atoi(data[14]) * 1000);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
interval = data[16] ? atoi(data[16]) : 0;
profileBlob = (float *)data[17];
tempBlob = (unsigned char *)data[18];
pressureBlob = (int *)data[19];
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
for (i = 0; interval && i * interval < state->cur_dive->duration.seconds; i++) {
sample_start(state);
state->cur_sample->time.seconds = i * interval;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (profileBlob)
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->depth.mm = lrintf(profileBlob[i] * 1000.0f);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
else
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->depth.mm = state->cur_dive->dc.maxdepth.mm;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[18] && data[18][0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->temperature.mkelvin = C_to_mkelvin(tempBlob[i]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[19] && data[19][0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->pressure[0].mbar = pressureBlob[i];
sample_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_events_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm4_events, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm4_events failed.\n");
return 1;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_tags_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm4_tags, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm4_tags failed.\n");
return 1;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
dive_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
for (i=0; i<columns;++i) {
fprintf(stderr, "%s\t", column[i]);
}
fprintf(stderr, "\n");
for (i=0; i<columns;++i) {
fprintf(stderr, "%s\t", data[i]);
}
fprintf(stderr, "\n");
//exit(0);
*/
return SQLITE_OK;
}
int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buffer, int size,
Parser: parse into custom dive site table To extend the undo system to dive sites, the importers and downloaders must not parse directly into the global dive site table. Instead, pass a dive_site_table argument to parse into. For now, always pass the global dive_site_table so that this commit should not cause any functional change. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-28 22:45:17 +01:00
struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(buffer);
UNUSED(size);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
int retval;
char *err = NULL;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state state;
init_parser_state(&state);
state.target_table = table;
Parser: add trip_table parameter to parsing functions To allow parsing into arbitrary trip_tables, add the corresponding parameter to the parsing functions and the parser state. Currently, all callers pass the global trip_table so there should be no change in functionality. These arguments will be replaced in subsequent commits. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-27 00:25:15 +01:00
state.trips = trips;
Parser: parse into custom dive site table To extend the undo system to dive sites, the importers and downloaders must not parse directly into the global dive site table. Instead, pass a dive_site_table argument to parse into. For now, always pass the global dive_site_table so that this commit should not cause any functional change. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-28 22:45:17 +01:00
state.sites = sites;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state.sql_handle = handle;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/* StartTime is converted from Suunto's nano seconds to standard
* time. We also need epoch, not seconds since year 1. */
char get_dives[] = "select D.DiveId,StartTime/10000000-62135596800,Note,Duration,SourceSerialNumber,Source,MaxDepth,SampleInterval,StartTemperature,BottomTemperature,D.StartPressure,D.EndPressure,Size,CylinderWorkPressure,SurfacePressure,DiveTime,SampleInterval,ProfileBlob,TemperatureBlob,PressureBlob,Oxygen,Helium,MIX.StartPressure,MIX.EndPressure FROM Dive AS D JOIN DiveMixture AS MIX ON D.DiveId=MIX.DiveId";
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
retval = sqlite3_exec(handle, get_dives, &dm4_dive, &state, &err);
free_parser_state(&state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "Database query failed '%s'.\n", url);
return 1;
}
return 0;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm5_cylinders(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cylinder_t *cyl;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Cleanup: return cylinder from cylinder_start() in parser Most callers of this function accessed the newly generated cylinder immediately after calling this function. Thus, for convenience, return the added cylinder. This avoids a number of verbose expressions. On the flip side, cylinder_start() now has to be cast to function returning void in a the "nesting" function table. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:59:14 +02:00
cyl = cylinder_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[7] && atoi(data[7]) > 0 && atoi(data[7]) < 350000)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->start.mbar = atoi(data[7]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[8] && atoi(data[8]) > 0 && atoi(data[8]) < 350000)
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->end.mbar = (atoi(data[8]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[6]) {
/* DM5 shows tank size of 12 liters when the actual
* value is 0 (and using metric units). So we just use
* the same 12 liters when size is not available */
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
if (strtod_flags(data[6], NULL, 0) == 0.0 && cyl->start.mbar)
cyl->type.size.mliter = 12000;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
else
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->type.size.mliter = lrint((strtod_flags(data[6], NULL, 0)) * 1000);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
if (data[2])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->gasmix.o2.permille = atoi(data[2]) * 10;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[3])
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 18:44:57 +02:00
cyl->gasmix.he.permille = atoi(data[3]) * 10;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
cylinder_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
return 0;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm5_gaschange(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
event_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_event.time.seconds = atoi(data[0]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[1]) {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
strcpy(state->cur_event.name, "gaschange");
state->cur_event.value = lrint(strtod_flags(data[1], NULL, 0));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
/* He part of the mix */
if (data[2])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_event.value += lrint(strtod_flags(data[2], NULL, 0)) << 16;
event_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
return 0;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
static int dm5_dive(void *param, int columns, char **data, char **column)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(columns);
UNUSED(column);
Cleanup: durations are now signed Somehow a whitespace fix snuck in here. Oops. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-12-17 09:12:08 -08:00
int i;
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
int tempformat = 0;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
int interval, retval = 0, block_size;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state *state = (struct parser_state *)param;
sqlite3 *handle = state->sql_handle;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
unsigned const char *sampleBlob;
char get_events_template[] = "select * from Mark where DiveId = %d";
char get_tags_template[] = "select Text from DiveTag where DiveId = %d";
char get_cylinders_template[] = "select * from DiveMixture where DiveId = %d";
char get_gaschange_template[] = "select GasChangeTime,Oxygen,Helium from DiveGasChange join DiveMixture on DiveGasChange.DiveMixtureId=DiveMixture.DiveMixtureId where DiveId = %d";
char get_events[512];
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
dive_start(state);
state->cur_dive->number = atoi(data[0]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->when = (time_t)(atol(data[1]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[2])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[2], &state->cur_dive->notes);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[3])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->duration.seconds = atoi(data[3]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[15])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.duration.seconds = atoi(data[15]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
* TODO: the deviceid hash should be calculated here.
*/
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
settings_start(state);
dc_settings_start(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[4]) {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[4], &state->cur_settings.dc.serial_nr);
state->cur_settings.dc.deviceid = atoi(data[4]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
if (data[5])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[5], &state->cur_settings.dc.model);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
dc_settings_end(state);
settings_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[6])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.maxdepth.mm = lrint(strtod_flags(data[6], NULL, 0) * 1000);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[8])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[9])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.watertemp.mkelvin = C_to_mkelvin(atoi(data[9]));
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[4]) {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.deviceid = atoi(data[4]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
if (data[5])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
utf8_string(data[5], &state->cur_dive->dc.model);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_cylinders_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm5_cylinders, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm5_cylinders failed.\n");
return 1;
}
if (data[14])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_dive->dc.surface_pressure.mbar = (atoi(data[14]) / 100);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
interval = data[16] ? atoi(data[16]) : 0;
Start to describe DM5 sampleBlob Currently the best guess of sampleBlob format. Unfortunately there seems to be some version of DM that stores the temperature in different location that I have not been able to figure out yet. Note that some version of DM does not utilize sampleBlob but specific blobs for each value (temperature, pressure, ...). Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:41:04 +03:00
/*
* sampleBlob[0] version number, indicates the size of one sample
*
* Following ones describe single sample, bugs in interpretation of the binary blob are likely:
*
* sampleBlob[3] depth
* sampleBlob[7-9] pressure
* sampleBlob[11] temperature - either full Celsius or float, might be different field for some version of DM
*/
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
sampleBlob = (unsigned const char *)data[24];
if (sampleBlob) {
switch (sampleBlob[0]) {
Explicitly mark DM4 conversion Same as default branch, but as 0x01 appears to be converted from DM4 to DM5, let's just be explicit about it. Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:45:30 +03:00
case 1:
// Log is converted from DM4 to DM5
block_size = 16;
break;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
case 2:
block_size = 19;
break;
case 3:
block_size = 23;
break;
case 4:
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
// Temperature is stored in float
tempformat = 1;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
block_size = 26;
break;
DM5 import: support for larger sample size Suunto has updated SampleBlob to use 30 byte blobs. This adds support for the increased size. Note that this only parses the same fields we have parsed before. (Currently I have no idea what the increased size is used for.) Note also that I do not currently have data with the new format so I only tested this still works with old data. Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-06-16 03:03:16 +03:00
case 5:
// Temperature is stored in float
tempformat = 1;
block_size = 30;
break;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
default:
block_size = 16;
break;
}
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
for (i = 0; interval && sampleBlob && i * interval < state->cur_dive->duration.seconds; i++) {
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
float *depth = (float *)&sampleBlob[i * block_size + 3];
int32_t pressure = (sampleBlob[i * block_size + 9] << 16) + (sampleBlob[i * block_size + 8] << 8) + sampleBlob[i * block_size + 7];
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
sample_start(state);
state->cur_sample->time.seconds = i * interval;
state->cur_sample->depth.mm = lrintf(depth[0] * 1000.0f);
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
if (tempformat == 1) {
float *temp = (float *)&(sampleBlob[i * block_size + 11]);
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->temperature.mkelvin = C_to_mkelvin(*temp);
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
} else {
Temperature 0x7F appears to mean no reading Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 08:15:15 +03:00
if ((sampleBlob[i * block_size + 11]) != 0x7F) {
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->temperature.mkelvin = C_to_mkelvin(sampleBlob[i * block_size + 11]);
Temperature 0x7F appears to mean no reading Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 08:15:15 +03:00
}
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
}
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/*
Handle int and float temperatures Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2018-04-07 07:46:37 +03:00
* Limit cylinder pressures to somewhat sensible values
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
*/
if (pressure >= 0 && pressure < 350000)
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->pressure[0].mbar = pressure;
sample_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
/*
* Log was converted from DM4, thus we need to parse the profile
* from DM4 format
*/
if (i == 0) {
float *profileBlob;
unsigned char *tempBlob;
int *pressureBlob;
profileBlob = (float *)data[17];
tempBlob = (unsigned char *)data[18];
pressureBlob = (int *)data[19];
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
for (i = 0; interval && i * interval < state->cur_dive->duration.seconds; i++) {
sample_start(state);
state->cur_sample->time.seconds = i * interval;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (profileBlob)
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->depth.mm = lrintf(profileBlob[i] * 1000.0f);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
else
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->depth.mm = state->cur_dive->dc.maxdepth.mm;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[18] && data[18][0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->temperature.mkelvin = C_to_mkelvin(tempBlob[i]);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (data[19] && data[19][0])
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state->cur_sample->pressure[0].mbar = pressureBlob[i];
sample_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
}
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_gaschange_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm5_gaschange, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm5_gaschange failed.\n");
return 1;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_events_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm4_events, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm4_events failed.\n");
return 1;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
snprintf(get_events, sizeof(get_events) - 1, get_tags_template, state->cur_dive->number);
Cleanup: pass NULL pointer for error string pointer Since we never did anything with the error string, why even ask for it. And this way we don't have to deal with the memory returned, either. Found by Coverity. Fixes CIDs 350124, 350113, 350106, 350099, 350091 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-10-26 17:11:44 -04:00
retval = sqlite3_exec(handle, get_events, &dm4_tags, state, NULL);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "%s", "Database query dm4_tags failed.\n");
return 1;
}
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
dive_end(state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
return SQLITE_OK;
}
int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buffer, int size,
Parser: parse into custom dive site table To extend the undo system to dive sites, the importers and downloaders must not parse directly into the global dive site table. Instead, pass a dive_site_table argument to parse into. For now, always pass the global dive_site_table so that this commit should not cause any functional change. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-28 22:45:17 +01:00
struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites)
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
{
core: replace (void) with UNUSED(x) and include ssrf.h Unused parameters in C are "silenced" by adding UNUSED(x) Signed-off-by: Jan Iversen <jani@apache.org>
2018-05-22 09:07:42 +02:00
UNUSED(buffer);
UNUSED(size);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
int retval;
char *err = NULL;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
struct parser_state state;
init_parser_state(&state);
state.target_table = table;
Parser: add trip_table parameter to parsing functions To allow parsing into arbitrary trip_tables, add the corresponding parameter to the parsing functions and the parser state. Currently, all callers pass the global trip_table so there should be no change in functionality. These arguments will be replaced in subsequent commits. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-27 00:25:15 +01:00
state.trips = trips;
Parser: parse into custom dive site table To extend the undo system to dive sites, the importers and downloaders must not parse directly into the global dive site table. Instead, pass a dive_site_table argument to parse into. For now, always pass the global dive_site_table so that this commit should not cause any functional change. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-28 22:45:17 +01:00
state.sites = sites;
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
state.sql_handle = handle;
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
/* StartTime is converted from Suunto's nano seconds to standard
* time. We also need epoch, not seconds since year 1. */
char get_dives[] = "select DiveId,StartTime/10000000-62135596800,Note,Duration,coalesce(SourceSerialNumber,SerialNumber),Source,MaxDepth,SampleInterval,StartTemperature,BottomTemperature,StartPressure,EndPressure,'','',SurfacePressure,DiveTime,SampleInterval,ProfileBlob,TemperatureBlob,PressureBlob,'','','','',SampleBlob FROM Dive where Deleted is null";
Parser: make parser (mostly) reentrant Introduce a parser_state structure, which describes (most) of the global parser state. Create such a structure in the entry routines to the parser and pass it down to the individual functions. The parser state is initialized and freed with the init_parser_state() and free_parser_state() functions. The main benefits are: 1) Isolation of parser state. 2) Keeping the global name space tidy. 3) Prevent memory leaks which could happen in truncated files by freeing all the parser state after parse. A somewhat controversial point might be that the individual parsing functions are split in those that need parser-state and those that don't. This means that there are now two versions of the MATCH macro, viz. one for the former and one for the latter. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-17 18:45:22 +02:00
retval = sqlite3_exec(handle, get_dives, &dm5_dive, &state, &err);
free_parser_state(&state);
Move Suunto DB import into its own file Signed-off-by: Miika Turkia <miika.turkia@gmail.com>
2017-11-28 21:24:53 +02:00
if (retval != SQLITE_OK) {
fprintf(stderr, "Database query failed '%s'.\n", url);
return 1;
}
return 0;
}
Reference in a new issue Copy permalink