int libdc_parser_create(parser_handle_t * abstract, dev_handle_t abstract_dev)
{
libdc_parser_t * parser = (libdc_parser_t *)(abstract);
libdc_device_t dev = (libdc_device_t)(abstract_dev);
if ((parser == NULL) || (dev == NULL))
{
errno = EINVAL;
return -1;
}
libdc_parser_t p = (libdc_parser_t)malloc(sizeof(struct libdc_parser_));
if (p == NULL)
return -1;
p->dev = dev;
p->parser = NULL;
dc_status_t rc = dc_parser_new(& p->parser, p->dev->device);
if (rc != DC_STATUS_SUCCESS)
{
dev->errcode = DRIVER_ERR_INVALID;
dev->errmsg = "Failed to create a libdivecomputer Parser";
free(p);
return -1;
}
libdc_parser_reset((parser_handle_t)p);
*abstract = (parser_handle_t)p;
return 0;
}
static int
dive_cb (const unsigned char *data, unsigned int size, const unsigned char *fingerprint, unsigned int fsize, void *userdata)
{
dive_data_t *divedata = (dive_data_t *) userdata;
dc_status_t rc = DC_STATUS_SUCCESS;
dc_parser_t *parser = NULL;
divedata->number++;
message ("Dive: number=%u, size=%u, fingerprint=", divedata->number, size);
for (unsigned int i = 0; i < fsize; ++i)
message ("%02X", fingerprint[i]);
message ("\n");
// Keep a copy of the most recent fingerprint. Because dives are
// guaranteed to be downloaded in reverse order, the most recent
// dive is always the first dive.
if (divedata->number == 1) {
dc_buffer_t *fp = dc_buffer_new (fsize);
dc_buffer_append (fp, fingerprint, fsize);
*divedata->fingerprint = fp;
}
// Create the parser.
message ("Creating the parser.\n");
rc = dc_parser_new (&parser, divedata->device);
if (rc != DC_STATUS_SUCCESS) {
ERROR ("Error creating the parser.");
goto cleanup;
}
// Register the data.
message ("Registering the data.\n");
rc = dc_parser_set_data (parser, data, size);
if (rc != DC_STATUS_SUCCESS) {
ERROR ("Error registering the data.");
goto cleanup;
}
// Parse the dive data.
message ("Parsing the dive data.\n");
rc = dctool_output_write (divedata->output, parser, data, size, fingerprint, fsize);
if (rc != DC_STATUS_SUCCESS) {
ERROR ("Error parsing the dive data.");
goto cleanup;
}
cleanup:
dc_parser_destroy (parser);
return 1;
}
static dc_status_t create_parser(device_data_t *devdata, dc_parser_t **parser)
{
return dc_parser_new(parser, devdata->device);
}
static dc_status_t
doparse(dif_dive_collection_t *dc, dc_device_t *device, const unsigned char data[], unsigned int size) {
dif_dive_t *dive = NULL;
unsigned int i = 0;
/* allocate the dive */
message("allocating the dive\n");
dive = dif_dive_alloc();
if (dive == NULL || dc == NULL) {
WARNING("Error creating the dive object");
return DC_STATUS_NOMEMORY;
}
dc = dif_dive_collection_add_dive(dc, dive);
/* create the parser */
message("Creating the parser.\n");
dc_parser_t *parser = NULL;
dc_status_t rc = dc_parser_new(&parser, device);
if (rc != DC_STATUS_SUCCESS) {
WARNING("Error creating the parser.");
return rc;
}
/* register the data with the parser */
message("Registering the data.\n");
rc = dc_parser_set_data(parser, data, size);
if (rc != DC_STATUS_SUCCESS) {
WARNING("Error registering the data.");
dc_parser_destroy(parser);
return rc;
}
/* parse the datetime of the dive*/
message("Parsing the datetime.\n");
dc_datetime_t dt = {0};
rc = dc_parser_get_datetime(parser, &dt);
if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
WARNING("Error parsing the datetime.");
dc_parser_destroy(parser);
return rc;
}
dive = dif_dive_set_datetime(dive, dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second);
/* parse the divetime - in seconds */
message("Parsing the divetime.\n");
unsigned int divetime = 0;
rc = dc_parser_get_field(parser, DC_FIELD_DIVETIME, 0, &divetime);
if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
WARNING("Error parsing the divetime.");
dc_parser_destroy(parser);
return rc;
}
dive = dif_dive_set_duration(dive, divetime);
/* parse the maximum depth */
message("Parsing the maximum depth.\n");
double maxdepth = 0.0;
rc = dc_parser_get_field(parser, DC_FIELD_MAXDEPTH, 0, &maxdepth);
if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
WARNING("Error parsing the maximum depth.");
dc_parser_destroy(parser);
return rc;
}
dive = dif_dive_set_maxdepth(dive, maxdepth);
/* parse the gas mixes */
message("Parsing the gas mixes.\n");
unsigned int ngases = 0;
rc = dc_parser_get_field(parser, DC_FIELD_GASMIX_COUNT, 0, &ngases);
if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
WARNING("Error parsing the gas mix count.");
dc_parser_destroy(parser);
return rc;
}
for (i=0; i < ngases; ++i) {
dc_gasmix_t gasmix = {0};
rc = dc_parser_get_field(parser, DC_FIELD_GASMIX, i, &gasmix);
if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
WARNING("Error parsing the gas mix.");
dc_parser_destroy(parser);
return rc;
}
dif_gasmix_t *mix = dif_gasmix_alloc();
if (mix == NULL) {
WARNING("Error allocating gas mix object.");
return DC_STATUS_NOMEMORY;
}
mix->id = i;
mix->helium = gasmix.helium * 100;
mix->oxygen = gasmix.oxygen * 100;
mix->nitrogen = gasmix.nitrogen * 100;
if (dif_gasmix_is_valid(mix)) {
dive = dif_dive_add_gasmix(dive, mix);
} else {
dif_gasmix_free(mix);
}
}
/* parse the sample data */
message("Parsing the sample data.\n");
sample_cb_data_t *cbdata = g_malloc(sizeof(sample_cb_data_t));
cbdata->dive = dive;
cbdata->sample = NULL;
rc = dc_parser_samples_foreach(parser, sample_cb, cbdata);
if (rc != DC_STATUS_SUCCESS) {
WARNING("Error parsing the sample data.");
dc_parser_destroy(parser);
return rc;
}
g_free(cbdata);
/* destroy the parser */
message("Destroying the parser.\n");
rc = dc_parser_destroy(parser);
if (rc != DC_STATUS_SUCCESS) {
WARNING("Error destroying the parser.");
return rc;
}
return DC_STATUS_SUCCESS;
}
