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

core: convert parse-xml.c and parse.c to C++

Browse source 
This was very annoying, because the old code was not const-clean
at all and trampled all over buffers. This makes the new code
pretty messy for now.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2024-02-28 22:01:51 +01:00 • committed by Michael Keller
parent a133c6c4db
commit 83b0c1da40
9 changed files with 216 additions and 207 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Subsurface-mobile.pro
View file

@ -62,8 +62,8 @@ SOURCES += subsurface-mobile-main.cpp \
core/globals.cpp \
core/liquivision.c \
core/load-git.cpp \
core/parse-xml.c \
core/parse.c \
core/parse-xml.cpp \
core/parse.cpp \
core/picture.c \
core/pictureobj.cpp \
core/sample.cpp \

4
core/CMakeLists.txt
View file

@ -134,8 +134,8 @@ set(SUBSURFACE_CORE_LIB_SRCS
ostctools.c
owning_ptrs.h
parse-gpx.cpp
parse-xml.c
parse.c
parse-xml.cpp
parse.cpp
parse.h
picture.c
picture.h

2
core/divesite.c
View file

@ -62,7 +62,7 @@ struct dive_site *get_dive_site_by_gps(const location_t *loc, struct dive_site_t
/* to avoid a bug where we have two dive sites with different name and the same GPS coordinates
* and first get the gps coordinates (reading a V2 file) and happen to get back "the other" name,
* this function allows us to verify if a very specific name/GPS combination already exists */
struct dive_site *get_dive_site_by_gps_and_name(char *name, const location_t *loc, struct dive_site_table *ds_table)
struct dive_site *get_dive_site_by_gps_and_name(const char *name, const location_t *loc, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;

2
core/divesite.h
View file

@ -62,7 +62,7 @@ struct dive_site *create_dive_site(const char *name, struct dive_site_table *ds_
struct dive_site *create_dive_site_with_gps(const char *name, const location_t *, struct dive_site_table *ds_table);
struct dive_site *get_dive_site_by_name(const char *name, struct dive_site_table *ds_table);
struct dive_site *get_dive_site_by_gps(const location_t *, struct dive_site_table *ds_table);
struct dive_site *get_dive_site_by_gps_and_name(char *name, const location_t *, struct dive_site_table *ds_table);
struct dive_site *get_dive_site_by_gps_and_name(const char *name, const location_t *, struct dive_site_table *ds_table);
struct dive_site *get_dive_site_by_gps_proximity(const location_t *, int distance, struct dive_site_table *ds_table);
struct dive_site *get_same_dive_site(const struct dive_site *);
bool dive_site_is_empty(struct dive_site *ds);

217
core/parse-xml.c → core/parse-xml.cpp
View file

@ -5,6 +5,7 @@
#endif
#include "ssrf.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
@ -12,7 +13,6 @@
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#define __USE_XOPEN
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/tree.h>
@ -42,9 +42,6 @@ int last_xml_version = -1;
static xmlDoc *test_xslt_transforms(xmlDoc *doc, const struct xml_params *params);
const struct units SI_units = SI_UNITS;
const struct units IMPERIAL_units = IMPERIAL_UNITS;
static void divedate(const char *buffer, timestamp_t *when, struct parser_state *state)
{
int d, m, y;
@ -84,7 +81,7 @@ static void divetime(const char *buffer, timestamp_t *when, struct parser_state
}
/* Libdivecomputer: "2011-03-20 10:22:38" */
static void divedatetime(char *buffer, timestamp_t *when, struct parser_state *state)
static void divedatetime(const char *buffer, timestamp_t *when, struct parser_state *state)
{
int y, m, d;
int hr, min, sec;
@ -105,7 +102,7 @@ enum ParseState {
FINDSTART,
FINDEND
};
static void divetags(char *buffer, struct tag_entry **tags)
static void divetags(const char *buffer, struct tag_entry **tags)
{
int i = 0, start = 0, end = 0;
enum ParseState state = FINDEND;
@ -118,9 +115,9 @@ static void divetags(char *buffer, struct tag_entry **tags)
} else if (state == FINDEND) {
/* Found end of tag */
if (i > 0 && buffer[i - 1] != '\\') {
buffer[i] = '\0';
std::string s(buffer + start, i - start);
state = FINDSTART;
taglist_add_tag(tags, buffer + start);
taglist_add_tag(tags, s.c_str());
} else {
state = FINDSTART;
}
@ -142,7 +139,7 @@ static void divetags(char *buffer, struct tag_entry **tags)
if (end < start)
end = len - 1;
if (len > 0) {
buffer[end + 1] = '\0';
std::string s(buffer + start, i - start);
taglist_add_tag(tags, buffer + start);
}
}
@ -184,13 +181,13 @@ union int_or_float {
double fp;
};
static enum number_type integer_or_float(char *buffer, union int_or_float *res)
static enum number_type integer_or_float(const char *buffer, union int_or_float *res)
{
const char *end;
return parse_float(buffer, &res->fp, &end);
}
static void pressure(char *buffer, pressure_t *pressure, struct parser_state *state)
static void pressure(const char *buffer, pressure_t *pressure, struct parser_state *state)
{
double mbar = 0.0;
union int_or_float val;
@ -201,16 +198,16 @@ static void pressure(char *buffer, pressure_t *pressure, struct parser_state *st
if (!val.fp)
break;
switch (state->xml_parsing_units.pressure) {
case PASCALS:
case units::PASCALS:
mbar = val.fp / 100;
break;
case BAR:
case units::BAR:
/* Assume mbar, but if it's really small, it's bar */
mbar = val.fp;
if (fabs(mbar) < 5000)
mbar = mbar * 1000;
break;
case PSI:
case units::PSI:
mbar = psi_to_mbar(val.fp);
break;
}
@ -224,17 +221,30 @@ static void pressure(char *buffer, pressure_t *pressure, struct parser_state *st
}
}
static void cylinder_use(char *buffer, enum cylinderuse *cyl_use, struct parser_state *state)
std::string trimspace(const char *s)
{
if (trimspace(buffer)) {
int use = cylinderuse_from_text(buffer);
while (isspace(*s))
++s;
if (!*s)
return std::string();
const char *end = s + strlen(s);
while (isspace(end[-1]))
--end;
return std::string(s, end - s);
}
static void cylinder_use(const char *buffer, enum cylinderuse *cyl_use, struct parser_state *state)
{
std::string trimmed = trimspace(buffer);
if (!trimmed.empty()) {
enum cylinderuse use = cylinderuse_from_text(trimmed.c_str());
*cyl_use = use;
if (use == OXYGEN)
state->o2pressure_sensor = state->cur_dive->cylinders.nr - 1;
}
}
static void salinity(char *buffer, int *salinity)
static void salinity(const char *buffer, int *salinity)
{
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
@ -246,17 +256,17 @@ static void salinity(char *buffer, int *salinity)
}
}
static void depth(char *buffer, depth_t *depth, struct parser_state *state)
static void depth(const char *buffer, depth_t *depth, struct parser_state *state)
{
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOATVAL:
switch (state->xml_parsing_units.length) {
case METERS:
case units::METERS:
depth->mm = lrint(val.fp * 1000);
break;
case FEET:
case units::FEET:
depth->mm = feet_to_mm(val.fp);
break;
}
@ -281,17 +291,17 @@ static void extra_data_end(struct parser_state *state)
state->cur_extra_data.key = state->cur_extra_data.value = NULL;
}
static void weight(char *buffer, weight_t *weight, struct parser_state *state)
static void weight(const char *buffer, weight_t *weight, struct parser_state *state)
{
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOATVAL:
switch (state->xml_parsing_units.weight) {
case KG:
case units::KG:
weight->grams = lrint(val.fp * 1000);
break;
case LBS:
case units::LBS:
weight->grams = lbs_to_grams(val.fp);
break;
}
@ -301,20 +311,20 @@ static void weight(char *buffer, weight_t *weight, struct parser_state *state)
}
}
static void temperature(char *buffer, temperature_t *temperature, struct parser_state *state)
static void temperature(const char *buffer, temperature_t *temperature, struct parser_state *state)
{
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOATVAL:
switch (state->xml_parsing_units.temperature) {
case KELVIN:
case units::KELVIN:
temperature->mkelvin = lrint(val.fp * 1000);
break;
case CELSIUS:
case units::CELSIUS:
temperature->mkelvin = C_to_mkelvin(val.fp);
break;
case FAHRENHEIT:
case units::FAHRENHEIT:
temperature->mkelvin = F_to_mkelvin(val.fp);
break;
}
@ -328,7 +338,7 @@ static void temperature(char *buffer, temperature_t *temperature, struct parser_
temperature->mkelvin = 0;
}
static void sampletime(char *buffer, duration_t *time)
static void sampletime(const char *buffer, duration_t *time)
{
int i;
int hr, min, sec;
@ -353,7 +363,7 @@ static void sampletime(char *buffer, duration_t *time)
}
}
static void offsettime(char *buffer, offset_t *time)
static void offsettime(const char *buffer, offset_t *time)
{
duration_t uoffset;
int sign = 1;
@ -367,7 +377,7 @@ static void offsettime(char *buffer, offset_t *time)
time->seconds = sign * uoffset.seconds;
}
static void duration(char *buffer, duration_t *time)
static void duration(const char *buffer, duration_t *time)
{
/* DivingLog 5.08 (and maybe other versions) appear to sometimes
* store the dive time as 44.00 instead of 44:00;
@ -383,7 +393,7 @@ static void duration(char *buffer, duration_t *time)
}
}
static void percent(char *buffer, fraction_t *fraction)
static void percent(const char *buffer, fraction_t *fraction)
{
double val;
const char *end;
@ -409,7 +419,7 @@ static void percent(char *buffer, fraction_t *fraction)
}
}
static void gasmix(char *buffer, fraction_t *fraction, struct parser_state *state)
static void gasmix(const char *buffer, fraction_t *fraction, struct parser_state *state)
{
/* libdivecomputer does negative percentages. */
if (*buffer == '-')
@ -417,14 +427,12 @@ static void gasmix(char *buffer, fraction_t *fraction, struct parser_state *stat
percent(buffer, fraction);
}
static void gasmix_nitrogen(char *buffer, struct gasmix *gasmix)
static void gasmix_nitrogen(const char *, struct gasmix *)
{
UNUSED(buffer);
UNUSED(gasmix);
/* Ignore n2 percentages. There's no value in them. */
}
static void cylindersize(char *buffer, volume_t *volume)
static void cylindersize(const char *buffer, volume_t *volume)
{
union int_or_float val;
@ -439,27 +447,30 @@ static void cylindersize(char *buffer, volume_t *volume)
}
}
static void event_name(char *buffer, char *name)
static void event_name(const char *buffer, char *name)
{
int size = trimspace(buffer);
if (size >= MAX_EVENT_NAME)
size = MAX_EVENT_NAME - 1;
memcpy(name, buffer, size);
std::string trimmed = trimspace(buffer);
size_t size = std::min(trimmed.size(), (size_t)MAX_EVENT_NAME);
memcpy(name, trimmed.data(), size);
name[size] = 0;
}
// We don't use gauge as a mode, and pscr doesn't exist as a libdc divemode
const char *libdc_divemode_text[] = { "oc", "cc", "pscr", "freedive", "gauge"};
static const char *libdc_divemode_text[] = { "oc", "cc", "pscr", "freedive", "gauge"};
/* Extract the dive computer type from the xml text buffer */
static void get_dc_type(char *buffer, enum divemode_t *dct)
static void get_dc_type(const char *buffer, enum divemode_t *dct)
{
if (trimspace(buffer)) {
for (enum divemode_t i = 0; i < NUM_DIVEMODE; i++) {
if (strcmp(buffer, divemode_text[i]) == 0)
*dct = i;
else if (strcmp(buffer, libdc_divemode_text[i]) == 0)
*dct = i;
std::string trimmed = trimspace(buffer);
if (!trimmed.empty()) {
for (int i = 0; i < NUM_DIVEMODE; i++) {
if (trimmed == divemode_text[i]) {
*dct = (divemode_t)i;
break;
} else if (trimmed == libdc_divemode_text[i]) {
*dct = (divemode_t)i;
break;
}
}
}
}
@ -468,14 +479,11 @@ static void get_dc_type(char *buffer, enum divemode_t *dct)
* the string contained in the xml divemode attribute and passed
* in buffer, below. Typical xml input would be:
* <event name='modechange' divemode='OC' /> */
static void event_divemode(char *buffer, int *value)
static void event_divemode(const char *buffer, int *value)
{
int size = trimspace(buffer);
if (size >= MAX_EVENT_NAME)
size = MAX_EVENT_NAME - 1;
buffer[size] = 0x0;
std::string trimmed = trimspace(buffer);
for (int i = 0; i < NUM_DIVEMODE; i++) {
if (!strcmp(buffer,divemode_text[i])) {
if (trimmed == divemode_text[i]) {
*value = i;
break;
}
@ -492,7 +500,7 @@ static int match_name(const char *pattern, const char *name)
return *pattern == '\0' && (*name == '\0' || *name == '.');
}
typedef void (*matchfn_t)(char *buffer, void *);
typedef void (*matchfn_t)(const char *buffer, void *);
static int match(const char *pattern, const char *name,
matchfn_t fn, char *buf, void *data)
{
@ -502,7 +510,7 @@ static int match(const char *pattern, const char *name,
return 1;
}
typedef void (*matchfn_state_t)(char *buffer, void *, struct parser_state *state);
typedef void (*matchfn_state_t)(const char *buffer, void *, struct parser_state *state);
static int match_state(const char *pattern, const char *name,
matchfn_state_t fn, char *buf, void *data, struct parser_state *state)
{
@ -522,32 +530,32 @@ static int match_state(const char *pattern, const char *name,
if (0) (fn)("test", dest, state); \
match_state(pattern, name, (matchfn_state_t) (fn), buf, dest, state); })
static void get_index(char *buffer, int *i)
static void get_index(const char *buffer, int *i)
{
*i = atoi(buffer);
}
static void get_bool(char *buffer, bool *i)
static void get_bool(const char *buffer, bool *i)
{
*i = atoi(buffer);
}
static void get_uint8(char *buffer, uint8_t *i)
static void get_uint8(const char *buffer, uint8_t *i)
{
*i = atoi(buffer);
}
static void get_uint16(char *buffer, uint16_t *i)
static void get_uint16(const char *buffer, uint16_t *i)
{
*i = atoi(buffer);
}
static void get_bearing(char *buffer, bearing_t *bearing)
static void get_bearing(const char *buffer, bearing_t *bearing)
{
bearing->degrees = atoi(buffer);
}
static void get_rating(char *buffer, int *i)
static void get_rating(const char *buffer, int *i)
{
int j = atoi(buffer);
if (j >= 0 && j <= 5) {
@ -555,24 +563,24 @@ static void get_rating(char *buffer, int *i)
}
}
static void double_to_o2pressure(char *buffer, o2pressure_t *i)
static void double_to_o2pressure(const char *buffer, o2pressure_t *i)
{
i->mbar = lrint(ascii_strtod(buffer, NULL) * 1000.0);
}
static void hex_value(char *buffer, uint32_t *i)
static void hex_value(const char *buffer, uint32_t *i)
{
*i = strtoul(buffer, NULL, 16);
}
static void dive_site(char *buffer, struct dive *d, struct parser_state *state)
static void dive_site(const char *buffer, struct dive *d, struct parser_state *state)
{
uint32_t uuid;
hex_value(buffer, &uuid);
add_dive_to_dive_site(d, get_dive_site_by_uuid(uuid, state->log->sites));
}
static void get_notrip(char *buffer, bool *notrip)
static void get_notrip(const char *buffer, bool *notrip)
{
*notrip = !strcmp(buffer, "NOTRIP");
}
@ -600,7 +608,7 @@ static void get_notrip(char *buffer, bool *notrip)
* - temperature == 32.0 -> garbage, it's a missing temperature (zero converted from C to F)
* - temperatures > 32.0 == Fahrenheit
*/
static void fahrenheit(char *buffer, temperature_t *temperature)
static void fahrenheit(const char *buffer, temperature_t *temperature)
{
union int_or_float val;
@ -638,7 +646,7 @@ static void fahrenheit(char *buffer, temperature_t *temperature)
* have to have some arbitrary cut-off point where we assume
* that smaller values mean bar.. Not good.
*/
static void psi_or_bar(char *buffer, pressure_t *pressure)
static void psi_or_bar(const char *buffer, pressure_t *pressure)
{
union int_or_float val;
@ -663,7 +671,7 @@ static int divinglog_fill_sample(struct sample *sample, const char *name, char *
0;
}
static void uddf_gasswitch(char *buffer, struct sample *sample, struct parser_state *state)
static void uddf_gasswitch(const char *buffer, struct sample *sample, struct parser_state *state)
{
int idx = atoi(buffer);
int seconds = sample->time.seconds;
@ -683,7 +691,7 @@ static int uddf_fill_sample(struct sample *sample, const char *name, char *buf,
0;
}
static void eventtime(char *buffer, duration_t *duration, struct parser_state *state)
static void eventtime(const char *buffer, duration_t *duration, struct parser_state *state)
{
sampletime(buffer, duration);
if (state->cur_sample)
@ -702,7 +710,7 @@ static void try_to_match_autogroup(const char *name, char *buf, struct parser_st
nonmatch("autogroup", name, buf);
}
static void get_cylinderindex(char *buffer, int16_t *i, struct parser_state *state)
static void get_cylinderindex(const char *buffer, int16_t *i, struct parser_state *state)
{
*i = atoi(buffer);
if (state->lastcylinderindex != *i) {
@ -711,12 +719,12 @@ static void get_cylinderindex(char *buffer, int16_t *i, struct parser_state *sta
}
}
static void get_sensor(char *buffer, int16_t *i)
static void get_sensor(const char *buffer, int16_t *i)
{
*i = atoi(buffer);
}
static void parse_libdc_deco(char *buffer, struct sample *s)
static void parse_libdc_deco(const char *buffer, struct sample *s)
{
if (strcmp(buffer, "deco") == 0) {
s->in_deco = true;
@ -976,7 +984,7 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu
nonmatch("sample", name, buf);
}
static void divinglog_place(char *place, struct dive *d, struct parser_state *state)
static void divinglog_place(const char *place, struct dive *d, struct parser_state *state)
{
char buffer[1024];
struct dive_site *ds;
@ -1044,7 +1052,7 @@ static int divinglog_dive_match(struct dive *dive, const char *name, char *buf,
*
* There are many variations on that. This handles the useful cases.
*/
static void uddf_datetime(char *buffer, timestamp_t *when, struct parser_state *state)
static void uddf_datetime(const char *buffer, timestamp_t *when, struct parser_state *state)
{
char c;
int y, m, d, hh, mm, ss;
@ -1080,11 +1088,11 @@ success:
*when = utc_mktime(&tm);
}
#define uddf_datedata(name, offset) \
static void uddf_##name(char *buffer, timestamp_t *when, struct parser_state *state) \
{ \
state->cur_tm.tm_##name = atoi(buffer) + offset; \
*when = utc_mktime(&state->cur_tm); \
#define uddf_datedata(name, offset) \
static void uddf_##name(const char *buffer, timestamp_t *when, struct parser_state *state) \
{ \
state->cur_tm.tm_##name = atoi(buffer) + offset; \
*when = utc_mktime(&state->cur_tm); \
}
uddf_datedata(year, 0)
@ -1154,7 +1162,7 @@ static degrees_t parse_degrees(const char *buf, const char **end)
return ret;
}
static void gps_lat(char *buffer, struct dive *dive, struct parser_state *state)
static void gps_lat(const char *buffer, struct dive *dive, struct parser_state *state)
{
const char *end;
location_t location = { };
@ -1170,7 +1178,7 @@ static void gps_lat(char *buffer, struct dive *dive, struct parser_state *state)
}
}
static void gps_long(char *buffer, struct dive *dive, struct parser_state *state)
static void gps_long(const char *buffer, struct dive *dive, struct parser_state *state)
{
const char *end;
location_t location = { };
@ -1187,7 +1195,7 @@ static void gps_long(char *buffer, struct dive *dive, struct parser_state *state
}
/* We allow either spaces or a comma between the decimal degrees */
void parse_location(const char *buffer, location_t *loc)
extern "C" void parse_location(const char *buffer, location_t *loc)
{
const char *end;
loc->lat = parse_degrees(buffer, &end);
@ -1195,12 +1203,12 @@ void parse_location(const char *buffer, location_t *loc)
loc->lon = parse_degrees(end, &end);
}
static void gps_location(char *buffer, struct dive_site *ds)
static void gps_location(const char *buffer, struct dive_site *ds)
{
parse_location(buffer, &ds->location);
}
static void gps_in_dive(char *buffer, struct dive *dive, struct parser_state *state)
static void gps_in_dive(const char *buffer, struct dive *dive, struct parser_state *state)
{
struct dive_site *ds = dive->dive_site;
location_t location;
@ -1234,7 +1242,7 @@ static void gps_in_dive(char *buffer, struct dive *dive, struct parser_state *st
}
}
static void gps_picture_location(char *buffer, struct picture *pic)
static void gps_picture_location(const char *buffer, struct picture *pic)
{
parse_location(buffer, &pic->location);
}
@ -1441,8 +1449,8 @@ static void try_to_fill_dive_site(struct parser_state *state, const char *name,
if (state->taxonomy_category < 0 || state->taxonomy_origin < 0) {
report_error("Warning: taxonomy value without origin or category");
} else {
taxonomy_set_category(&ds->taxonomy, state->taxonomy_category,
taxonomy_value, state->taxonomy_origin);
taxonomy_set_category(&ds->taxonomy, (taxonomy_category)state->taxonomy_category,
taxonomy_value, (taxonomy_origin)state->taxonomy_origin);
}
state->taxonomy_category = state->taxonomy_origin = -1;
free(taxonomy_value);
@ -1644,8 +1652,8 @@ static void uddf_importer(struct parser_state *state)
{
state->import_source = UDDF;
state->xml_parsing_units = SI_units;
state->xml_parsing_units.pressure = PASCALS;
state->xml_parsing_units.temperature = KELVIN;
state->xml_parsing_units.pressure = units::PASCALS;
state->xml_parsing_units.temperature = units::KELVIN;
}
typedef void (*parser_func)(struct parser_state *);
@ -1738,7 +1746,7 @@ static void reset_all(struct parser_state *state)
* declaration and decode the HTML encoded characters */
static const char *preprocess_divelog_de(const char *buffer)
{
char *ret = strstr(buffer, "<DIVELOGSDATA>");
const char *ret = strstr(buffer, "<DIVELOGSDATA>");
if (ret) {
xmlParserCtxtPtr ctx;
@ -1757,10 +1765,9 @@ static const char *preprocess_divelog_de(const char *buffer)
return buffer;
}
int parse_xml_buffer(const char *url, const char *buffer, int size, struct divelog *log,
const struct xml_params *params)
extern "C" int parse_xml_buffer(const char *url, const char *buffer, int, struct divelog *log,
const struct xml_params *params)
{
UNUSED(size);
xmlDoc *doc;
const char *res = preprocess_divelog_de(buffer);
int ret = 0;
@ -1810,7 +1817,7 @@ static timestamp_t parse_dlf_timestamp(unsigned char *buffer)
return offset + 946684800;
}
int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
extern "C" int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
{
unsigned char *ptr = buffer;
unsigned char event;
@ -2136,8 +2143,8 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
char config_buf[256];
// Local variables to temporary decode into
struct tm tm;
char *device;
char *deep_stops;
const char *device;
const char *deep_stops;
case 0: // TEST_CCR_FULL_1
utc_mkdate(parse_dlf_timestamp(ptr + 12), &tm);
snprintf(config_buf, sizeof(config_buf), "START=%04u-%02u-%02u %02u:%02u:%02u,TEST=%02X%02X%02X%02X,RESULT=%02X%02X%02X%02X", tm.tm_year, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, ptr[7], ptr[6], ptr[5], ptr[4], ptr[11], ptr[10], ptr[9], ptr[8]);
@ -2261,7 +2268,7 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
/* Recording the starting battery status to extra data */
if (battery_start.volt1) {
size_t stringsize = snprintf(NULL, 0, "%dmV (%d%%)", battery_start.volt1, battery_start.percent1) + 1;
char *ptr = malloc(stringsize);
char *ptr = (char *)malloc(stringsize);
if (ptr) {
snprintf(ptr, stringsize, "%dmV (%d%%)", battery_start.volt1, battery_start.percent1);
@ -2270,7 +2277,7 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
}
stringsize = snprintf(NULL, 0, "%dmV (%d%%)", battery_start.volt2, battery_start.percent2) + 1;
ptr = malloc(stringsize);
ptr = (char *)malloc(stringsize);
if (ptr) {
snprintf(ptr, stringsize, "%dmV (%d%%)", battery_start.volt2, battery_start.percent2);
add_extra_data(state.cur_dc, "Battery 2 (start)", ptr);
@ -2281,7 +2288,7 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
/* Recording the ending battery status to extra data */
if (battery_end.volt1) {
size_t stringsize = snprintf(NULL, 0, "%dmV (%d%%)", battery_end.volt1, battery_end.percent1) + 1;
char *ptr = malloc(stringsize);
char *ptr = (char *)malloc(stringsize);
if (ptr) {
snprintf(ptr, stringsize, "%dmV (%d%%)", battery_end.volt1, battery_end.percent1);
@ -2290,7 +2297,7 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
}
stringsize = snprintf(NULL, 0, "%dmV (%d%%)", battery_end.volt2, battery_end.percent2) + 1;
ptr = malloc(stringsize);
ptr = (char *)malloc(stringsize);
if (ptr) {
snprintf(ptr, stringsize, "%dmV (%d%%)", battery_end.volt2, battery_end.percent2);
add_extra_data(state.cur_dc, "Battery 2 (end)", ptr);
@ -2305,12 +2312,12 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log)
}
void parse_xml_init(void)
extern "C" void parse_xml_init(void)
{
LIBXML_TEST_VERSION
}
void parse_xml_exit(void)
extern "C" void parse_xml_exit(void)
{
xmlCleanupParser();
}

172
core/parse.c → core/parse.cpp
View file

@ -19,7 +19,7 @@
#include "device.h"
#include "gettext.h"
void init_parser_state(struct parser_state *state)
extern "C" void init_parser_state(struct parser_state *state)
{
memset(state, 0, sizeof(*state));
state->metric = true;
@ -27,7 +27,7 @@ void init_parser_state(struct parser_state *state)
state->sample_rate = 0;
}
void free_parser_state(struct parser_state *state)
extern "C" void free_parser_state(struct parser_state *state)
{
free_dive(state->cur_dive);
free_trip(state->cur_trip);
@ -53,63 +53,40 @@ void free_parser_state(struct parser_state *state)
* If we don't have an explicit dive computer,
* we use the implicit one that every dive has..
*/
struct divecomputer *get_dc(struct parser_state *state)
extern "C" struct divecomputer *get_dc(struct parser_state *state)
{
return state->cur_dc ?: &state->cur_dive->dc;
}
/* Trim a character string by removing leading and trailing white space characters.
* Parameter: a pointer to a null-terminated character string (buffer);
* Return value: length of the trimmed string, excluding the terminal 0x0 byte
* The original pointer (buffer) remains valid after this function has been called
* and points to the trimmed string */
int trimspace(char *buffer)
{
int i, size, start, end;
size = strlen(buffer);
if (!size)
return 0;
for(start = 0; isspace(buffer[start]); start++)
if (start >= size) return 0; // Find 1st character following leading whitespace
for(end = size - 1; isspace(buffer[end]); end--) // Find last character before trailing whitespace
if (end <= 0) return 0;
for(i = start; i <= end; i++) // Move the nonspace characters to the start of the string
buffer[i-start] = buffer[i];
size = end - start + 1;
buffer[size] = 0x0; // then terminate the string
return size; // return string length
}
/*
* Add a dive into the dive_table array
*/
void record_dive_to_table(struct dive *dive, struct dive_table *table)
extern "C" void record_dive_to_table(struct dive *dive, struct dive_table *table)
{
add_to_dive_table(table, table->nr, fixup_dive(dive));
}
void start_match(const char *type, const char *name, char *buffer)
extern "C" void start_match(const char *type, const char *name, char *buffer)
{
if (verbose > 2)
printf("Matching %s '%s' (%s)\n",
type, name, buffer);
}
void nonmatch(const char *type, const char *name, char *buffer)
extern "C" void nonmatch(const char *type, const char *name, char *buffer)
{
if (verbose > 1)
printf("Unable to match %s '%s' (%s)\n",
type, name, buffer);
}
void event_start(struct parser_state *state)
extern "C" void event_start(struct parser_state *state)
{
memset(&state->cur_event, 0, sizeof(state->cur_event));
state->cur_event.deleted = 0; /* Active */
}
void event_end(struct parser_state *state)
extern "C" void event_end(struct parser_state *state)
{
struct divecomputer *dc = get_dc(state);
if (state->cur_event.type == 123) {
@ -159,20 +136,19 @@ void event_end(struct parser_state *state)
* to make a dive valid, but if it has no location, no date and no
* samples I'm pretty sure it's useless.
*/
bool is_dive(struct parser_state *state)
extern "C" bool is_dive(struct parser_state *state)
{
return state->cur_dive &&
(state->cur_dive->dive_site || state->cur_dive->when || state->cur_dive->dc.samples);
}
void reset_dc_info(struct divecomputer *dc, struct parser_state *state)
extern "C" void reset_dc_info(struct divecomputer *, struct parser_state *state)
{
/* WARN: reset dc info does't touch the dc? */
UNUSED(dc);
state->lastcylinderindex = 0;
}
void reset_dc_settings(struct parser_state *state)
extern "C" void reset_dc_settings(struct parser_state *state)
{
free((void *)state->cur_settings.dc.model);
free((void *)state->cur_settings.dc.nickname);
@ -185,7 +161,7 @@ void reset_dc_settings(struct parser_state *state)
state->cur_settings.dc.deviceid = 0;
}
void reset_fingerprint(struct parser_state *state)
extern "C" void reset_fingerprint(struct parser_state *state)
{
free((void *)state->cur_settings.fingerprint.data);
state->cur_settings.fingerprint.data = NULL;
@ -195,22 +171,22 @@ void reset_fingerprint(struct parser_state *state)
state->cur_settings.fingerprint.fdiveid = 0;
}
void settings_start(struct parser_state *state)
extern "C" void settings_start(struct parser_state *state)
{
state->in_settings = true;
}
void settings_end(struct parser_state *state)
extern "C" void settings_end(struct parser_state *state)
{
state->in_settings = false;
}
void fingerprint_settings_start(struct parser_state *state)
extern "C" void fingerprint_settings_start(struct parser_state *state)
{
reset_fingerprint(state);
}
void fingerprint_settings_end(struct parser_state *state)
extern "C" void fingerprint_settings_end(struct parser_state *state)
{
create_fingerprint_node_from_hex(state->fingerprints,
state->cur_settings.fingerprint.model,
@ -219,12 +195,13 @@ void fingerprint_settings_end(struct parser_state *state)
state->cur_settings.fingerprint.fdeviceid,
state->cur_settings.fingerprint.fdiveid);
}
void dc_settings_start(struct parser_state *state)
extern "C" void dc_settings_start(struct parser_state *state)
{
reset_dc_settings(state);
}
void dc_settings_end(struct parser_state *state)
extern "C" void dc_settings_end(struct parser_state *state)
{
create_device_node(state->log->devices,
state->cur_settings.dc.model,
@ -233,16 +210,16 @@ void dc_settings_end(struct parser_state *state)
reset_dc_settings(state);
}
void dive_site_start(struct parser_state *state)
extern "C" void dive_site_start(struct parser_state *state)
{
if (state->cur_dive_site)
return;
state->taxonomy_category = -1;
state->taxonomy_origin = -1;
state->cur_dive_site = calloc(1, sizeof(struct dive_site));
state->cur_dive_site = (dive_site *)calloc(1, sizeof(struct dive_site));
}
void dive_site_end(struct parser_state *state)
extern "C" void dive_site_end(struct parser_state *state)
{
if (!state->cur_dive_site)
return;
@ -257,28 +234,28 @@ void dive_site_end(struct parser_state *state)
state->cur_dive_site = NULL;
}
void filter_preset_start(struct parser_state *state)
extern "C" void filter_preset_start(struct parser_state *state)
{
if (state->cur_filter)
return;
state->cur_filter = alloc_filter_preset();
}
void filter_preset_end(struct parser_state *state)
extern "C" void filter_preset_end(struct parser_state *state)
{
add_filter_preset_to_table(state->cur_filter, state->log->filter_presets);
free_filter_preset(state->cur_filter);
state->cur_filter = NULL;
}
void fulltext_start(struct parser_state *state)
extern "C" void fulltext_start(struct parser_state *state)
{
if (!state->cur_filter)
return;
state->in_fulltext = true;
}
void fulltext_end(struct parser_state *state)
extern "C" void fulltext_end(struct parser_state *state)
{
if (!state->in_fulltext)
return;
@ -290,14 +267,14 @@ void fulltext_end(struct parser_state *state)
state->in_fulltext = false;
}
void filter_constraint_start(struct parser_state *state)
extern "C" void filter_constraint_start(struct parser_state *state)
{
if (!state->cur_filter)
return;
state->in_filter_constraint = true;
}
void filter_constraint_end(struct parser_state *state)
extern "C" void filter_constraint_end(struct parser_state *state)
{
if (!state->in_filter_constraint)
return;
@ -316,7 +293,7 @@ void filter_constraint_end(struct parser_state *state)
state->in_filter_constraint = false;
}
void dive_start(struct parser_state *state)
extern "C" void dive_start(struct parser_state *state)
{
if (state->cur_dive)
return;
@ -326,7 +303,7 @@ void dive_start(struct parser_state *state)
state->o2pressure_sensor = 1;
}
void dive_end(struct parser_state *state)
extern "C" void dive_end(struct parser_state *state)
{
if (!state->cur_dive)
return;
@ -343,7 +320,7 @@ void dive_end(struct parser_state *state)
state->cur_location.lon.udeg = 0;
}
void trip_start(struct parser_state *state)
extern "C" void trip_start(struct parser_state *state)
{
if (state->cur_trip)
return;
@ -352,7 +329,7 @@ void trip_start(struct parser_state *state)
memset(&state->cur_tm, 0, sizeof(state->cur_tm));
}
void trip_end(struct parser_state *state)
extern "C" void trip_end(struct parser_state *state)
{
if (!state->cur_trip)
return;
@ -360,32 +337,32 @@ void trip_end(struct parser_state *state)
state->cur_trip = NULL;
}
void picture_start(struct parser_state *state)
extern "C" void picture_start(struct parser_state *state)
{
}
void picture_end(struct parser_state *state)
extern "C" void picture_end(struct parser_state *state)
{
add_picture(&state->cur_dive->pictures, state->cur_picture);
/* dive_add_picture took ownership, we can just clear out copy of the data */
state->cur_picture = empty_picture;
}
cylinder_t *cylinder_start(struct parser_state *state)
extern "C" cylinder_t *cylinder_start(struct parser_state *state)
{
return add_empty_cylinder(&state->cur_dive->cylinders);
}
void cylinder_end(struct parser_state *state)
extern "C" void cylinder_end(struct parser_state *state)
{
}
void ws_start(struct parser_state *state)
extern "C" void ws_start(struct parser_state *state)
{
add_cloned_weightsystem(&state->cur_dive->weightsystems, empty_weightsystem);
}
void ws_end(struct parser_state *state)
extern "C" void ws_end(struct parser_state *state)
{
}
@ -415,7 +392,7 @@ static int sanitize_sensor_id(const struct dive *d, int nr)
* or the second cylinder depending on what isn't an
* oxygen cylinder.
*/
void sample_start(struct parser_state *state)
extern "C" void sample_start(struct parser_state *state)
{
struct divecomputer *dc = get_dc(state);
struct sample *sample = prepare_sample(dc);
@ -432,7 +409,7 @@ void sample_start(struct parser_state *state)
state->next_o2_sensor = 0;
}
void sample_end(struct parser_state *state)
extern "C" void sample_end(struct parser_state *state)
{
if (!state->cur_dive)
return;
@ -441,7 +418,7 @@ void sample_end(struct parser_state *state)
state->cur_sample = NULL;
}
void divecomputer_start(struct parser_state *state)
extern "C" void divecomputer_start(struct parser_state *state)
{
struct divecomputer *dc;
@ -452,7 +429,7 @@ void divecomputer_start(struct parser_state *state)
/* Did we already fill that in? */
if (dc->samples || dc->model || dc->when) {
struct divecomputer *newdc = calloc(1, sizeof(*newdc));
struct divecomputer *newdc = (divecomputer *)calloc(1, sizeof(*newdc));
if (newdc) {
dc->next = newdc;
dc = newdc;
@ -464,19 +441,19 @@ void divecomputer_start(struct parser_state *state)
reset_dc_info(dc, state);
}
void divecomputer_end(struct parser_state *state)
extern "C" void divecomputer_end(struct parser_state *state)
{
if (!state->cur_dc->when)
state->cur_dc->when = state->cur_dive->when;
state->cur_dc = NULL;
}
void userid_start(struct parser_state *state)
extern "C" void userid_start(struct parser_state *state)
{
state->in_userid = true;
}
void userid_stop(struct parser_state *state)
extern "C" void userid_stop(struct parser_state *state)
{
state->in_userid = false;
}
@ -486,42 +463,64 @@ void userid_stop(struct parser_state *state)
* therefore make sure to only pass in to NULL-initialized pointers or pointers
* to owned strings
*/
void utf8_string(char *buffer, void *_res)
extern "C" void utf8_string(const char *buffer, void *_res)
{
char **res = _res;
int size;
char **res = (char **)_res;
free(*res);
size = trimspace(buffer);
if(size)
*res = strdup(buffer);
while (isspace(*buffer))
++buffer;
if (!*buffer) {
*res = strdup("");
return;
}
const char *end = buffer + strlen(buffer);
while (isspace(end[-1]))
--end;
size_t len = end - buffer;
*res = (char *)malloc(len + 1);
memcpy(*res, buffer, len);
(*res)[len] = '\0';
}
void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
void utf8_string_std(const char *buffer, std::string *res)
{
char *buffer = ds_name;
char *to_free = NULL;
int size = trimspace(buffer);
if (size) {
while (isspace(*buffer))
++buffer;
if (!*buffer) {
res->clear();
return;
}
const char *end = buffer + strlen(buffer);
while (isspace(end[-1]))
--end;
*res = std::string(buffer, end - buffer);
}
extern "C" void add_dive_site(const char *ds_name, struct dive *dive, struct parser_state *state)
{
const char *buffer = ds_name;
std::string trimmed = trimspace(buffer);
if (!trimmed.empty()) {
struct dive_site *ds = dive->dive_site;
if (!ds) {
// if the dive doesn't have a dive site, check if there's already a dive site by this name
ds = get_dive_site_by_name(buffer, state->log->sites);
ds = get_dive_site_by_name(trimmed.c_str(), state->log->sites);
}
if (ds) {
// we have a dive site, let's hope there isn't a different name
if (empty_string(ds->name)) {
ds->name = copy_string(buffer);
} else if (!same_string(ds->name, buffer)) {
ds->name = copy_string(trimmed.c_str());
} else if (trimmed != ds->name) {
// if it's not the same name, it's not the same dive site
// but wait, we could have gotten this one based on GPS coords and could
// have had two different names for the same site... so let's search the other
// way around
struct dive_site *exact_match = get_dive_site_by_gps_and_name(buffer, &ds->location, state->log->sites);
struct dive_site *exact_match = get_dive_site_by_gps_and_name(trimmed.c_str(), &ds->location, state->log->sites);
if (exact_match) {
unregister_dive_from_dive_site(dive);
add_dive_to_dive_site(dive, exact_match);
} else {
struct dive_site *newds = create_dive_site(buffer, state->log->sites);
struct dive_site *newds = create_dive_site(trimmed.c_str(), state->log->sites);
unregister_dive_from_dive_site(dive);
add_dive_to_dive_site(dive, newds);
if (has_location(&state->cur_location)) {
@ -538,13 +537,12 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
add_dive_to_dive_site(dive, ds);
}
} else {
add_dive_to_dive_site(dive, create_dive_site(buffer, state->log->sites));
add_dive_to_dive_site(dive, create_dive_site(trimmed.c_str(), state->log->sites));
}
}
free(to_free);
}
int atoi_n(char *ptr, unsigned int len)
extern "C" int atoi_n(char *ptr, unsigned int len)
{
if (len < 10) {
char buf[10];

7
core/parse.h
View file

@ -102,7 +102,6 @@ extern "C" {
void init_parser_state(struct parser_state *state);
void free_parser_state(struct parser_state *state);
int trimspace(char *buffer);
void start_match(const char *type, const char *name, char *buffer);
void nonmatch(const char *type, const char *name, char *buffer);
void event_start(struct parser_state *state);
@ -143,9 +142,9 @@ void divecomputer_start(struct parser_state *state);
void divecomputer_end(struct parser_state *state);
void userid_start(struct parser_state *state);
void userid_stop(struct parser_state *state);
void utf8_string(char *buffer, void *_res);
void utf8_string(const char *buffer, void *_res);
void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state);
void add_dive_site(const char *ds_name, struct dive *dive, struct parser_state *state);
int atoi_n(char *ptr, unsigned int len);
void parse_xml_init(void);
@ -161,6 +160,8 @@ int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buf, in
int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log);
#ifdef __cplusplus
}
#include <string>
std::string trimspace(const char *buffer);
#endif
#endif

9
core/units.c
View file

@ -3,6 +3,15 @@
#include "gettext.h"
#include "pref.h"
#define IMPERIAL_UNITS \
{ \
.length = FEET, .volume = CUFT, .pressure = PSI, .temperature = FAHRENHEIT, .weight = LBS, \
.vertical_speed_time = MINUTES, .duration_units = MIXED, .show_units_table = false \
}
const struct units SI_units = SI_UNITS;
const struct units IMPERIAL_units = IMPERIAL_UNITS;
int get_pressure_units(int mb, const char **units)
{
int pressure;

6
core/units.h
View file

@ -333,12 +333,6 @@ struct units {
.vertical_speed_time = MINUTES, .duration_units = MIXED, .show_units_table = false \
}
#define IMPERIAL_UNITS \
{ \
.length = FEET, .volume = CUFT, .pressure = PSI, .temperature = FAHRENHEIT, .weight = LBS, \
.vertical_speed_time = MINUTES, .duration_units = MIXED, .show_units_table = false \
}
extern const struct units SI_units, IMPERIAL_units;
extern const struct units *get_units(void);