FlapJackApps/libdivecomputer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename the backend from darwinair to darwin.

Browse Source 
The name change makes it more obvious the backend supports both the
Darwin and the Darwin Air, and it's a shorter name too.
This commit is contained in:
Jef Driesen 2011-12-31 06:52:57 +01:00
parent ca56b5932a
commit 3d78282cde
10 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/mares_darwinair_test.c
View File

@ -21,7 +21,7 @@
#include <stdio.h> // fopen, fwrite, fclose
#include "mares_darwinair.h"
#include "mares_darwin.h"
#include "utils.h"
#include "common.h"
@ -31,8 +31,8 @@ test_dump_memory (const char* name, const char* filename)
{
device_t *device = NULL;
message ("mares_darwinair_device_open\n");
device_status_t rc = mares_darwinair_device_open (&device, name, 0);
message ("mares_darwin_device_open\n");
device_status_t rc = mares_darwin_device_open (&device, name, 0);
if (rc != DEVICE_STATUS_SUCCESS) {
WARNING ("Error opening serial port.");
return rc;

10
examples/universal.c
View File

@ -90,7 +90,7 @@ static const backend_table_t g_backends[] = {
{"atom2", DEVICE_TYPE_OCEANIC_ATOM2},
{"nemo", DEVICE_TYPE_MARES_NEMO},
{"puck", DEVICE_TYPE_MARES_PUCK},
{"darwinair", DEVICE_TYPE_MARES_DARWINAIR},
{"darwin", DEVICE_TYPE_MARES_DARWIN},
{"iconhd", DEVICE_TYPE_MARES_ICONHD},
{"ostc", DEVICE_TYPE_HW_OSTC},
{"edy", DEVICE_TYPE_CRESSI_EDY},
@ -335,8 +335,8 @@ doparse (FILE *fp, device_data_t *devdata, const unsigned char data[], unsigned
case DEVICE_TYPE_MARES_PUCK:
rc = mares_nemo_parser_create (&parser, devdata->devinfo.model);
break;
case DEVICE_TYPE_MARES_DARWINAIR:
rc = mares_darwinair_parser_create (&parser, devdata->devinfo.model);
case DEVICE_TYPE_MARES_DARWIN:
rc = mares_darwin_parser_create (&parser, devdata->devinfo.model);
break;
case DEVICE_TYPE_MARES_ICONHD:
rc = mares_iconhd_parser_create (&parser, devdata->devinfo.model);
@ -634,8 +634,8 @@ dowork (device_type_t backend, const char *devname, const char *rawfile, const c
case DEVICE_TYPE_MARES_PUCK:
rc = mares_puck_device_open (&device, devname);
break;
case DEVICE_TYPE_MARES_DARWINAIR:
rc = mares_darwinair_device_open (&device, devname, 0);
case DEVICE_TYPE_MARES_DARWIN:
rc = mares_darwin_device_open (&device, devname, 0);
break;
case DEVICE_TYPE_MARES_ICONHD:
rc = mares_iconhd_device_open (&device, devname);

4
src/Makefile.am
View File

@ -32,7 +32,7 @@ libdivecomputer_HEADERS = \
mares.h \
mares_nemo.h \
mares_puck.h \
mares_darwinair.h \
mares_darwin.h \
mares_iconhd.h \
hw.h \
hw_ostc.h \
@ -87,7 +87,7 @@ libdivecomputer_la_SOURCES = \
mares_common.h mares_common.c \
mares_nemo.h mares_nemo.c mares_nemo_parser.c \
mares_puck.h mares_puck.c \
mares_darwinair.h mares_darwinair.c mares_darwinair_parser.c \
mares_darwin.h mares_darwin.c mares_darwin_parser.c \
mares_iconhd.h mares_iconhd.c mares_iconhd_parser.c \
hw.h \
hw_ostc.h hw_ostc.c hw_ostc_parser.c \

2
src/device.h
View File

@ -47,7 +47,7 @@ typedef enum device_type_t {
DEVICE_TYPE_OCEANIC_VTPRO,
DEVICE_TYPE_MARES_NEMO,
DEVICE_TYPE_MARES_PUCK,
DEVICE_TYPE_MARES_DARWINAIR,
DEVICE_TYPE_MARES_DARWIN,
DEVICE_TYPE_MARES_ICONHD,
DEVICE_TYPE_HW_OSTC,
DEVICE_TYPE_CRESSI_EDY,

6
src/libdivecomputer.symbols
View File

@ -36,7 +36,7 @@ suunto_solution_parser_create
suunto_eon_parser_create
suunto_d9_parser_create
mares_nemo_parser_create
mares_darwinair_parser_create
mares_darwin_parser_create
mares_iconhd_parser_create
oceanic_vtpro_parser_create
oceanic_veo250_parser_create
@ -65,8 +65,8 @@ mares_nemo_device_open
mares_nemo_extract_dives
mares_puck_device_open
mares_puck_extract_dives
mares_darwinair_device_open
mares_darwinair_extract_dives
mares_darwin_device_open
mares_darwin_extract_dives
mares_iconhd_device_open
mares_iconhd_extract_dives
oceanic_atom2_device_open

2
src/mares.h
View File

@ -24,7 +24,7 @@
#include "mares_nemo.h"
#include "mares_puck.h"
#include "mares_darwinair.h"
#include "mares_darwin.h"
#include "mares_iconhd.h"
#endif /* MARES_H */

74
src/mares_darwinair.c → src/mares_darwin.c
View File

@ -25,7 +25,7 @@
#include "device-private.h"
#include "mares_common.h"
#include "mares_darwinair.h"
#include "mares_darwin.h"
#include "units.h"
#include "utils.h"
#include "array.h"
@ -33,7 +33,7 @@
#define DARWIN 0
#define DARWINAIR 1
typedef struct mares_darwinair_layout_t {
typedef struct mares_darwin_layout_t {
// Memory size.
unsigned int memsize;
// Logbook ringbuffer.
@ -45,32 +45,32 @@ typedef struct mares_darwinair_layout_t {
unsigned int rb_profile_end;
// Sample size
unsigned int samplesize;
} mares_darwinair_layout_t;
} mares_darwin_layout_t;
typedef struct mares_darwinair_device_t {
typedef struct mares_darwin_device_t {
mares_common_device_t base;
const mares_darwinair_layout_t *layout;
const mares_darwin_layout_t *layout;
unsigned int model;
unsigned char fingerprint[6];
} mares_darwinair_device_t;
} mares_darwin_device_t;
static device_status_t mares_darwinair_device_set_fingerprint (device_t *abstract, const unsigned char data[], unsigned int size);
static device_status_t mares_darwinair_device_dump (device_t *abstract, dc_buffer_t *buffer);
static device_status_t mares_darwinair_device_foreach (device_t *abstract, dive_callback_t callback, void *userdata);
static device_status_t mares_darwinair_device_close (device_t *abstract);
static device_status_t mares_darwin_device_set_fingerprint (device_t *abstract, const unsigned char data[], unsigned int size);
static device_status_t mares_darwin_device_dump (device_t *abstract, dc_buffer_t *buffer);
static device_status_t mares_darwin_device_foreach (device_t *abstract, dive_callback_t callback, void *userdata);
static device_status_t mares_darwin_device_close (device_t *abstract);
static const device_backend_t mares_darwinair_device_backend = {
DEVICE_TYPE_MARES_DARWINAIR,
mares_darwinair_device_set_fingerprint, /* set_fingerprint */
static const device_backend_t mares_darwin_device_backend = {
DEVICE_TYPE_MARES_DARWIN,
mares_darwin_device_set_fingerprint, /* set_fingerprint */
NULL, /* version */
mares_common_device_read, /* read */
NULL, /* write */
mares_darwinair_device_dump, /* dump */
mares_darwinair_device_foreach, /* foreach */
mares_darwinair_device_close /* close */
mares_darwin_device_dump, /* dump */
mares_darwin_device_foreach, /* foreach */
mares_darwin_device_close /* close */
};
static const mares_darwinair_layout_t mares_darwin_layout = {
static const mares_darwin_layout_t mares_darwin_layout = {
0x4000, /* memsize */
0x0100, /* rb_logbook_offset */
52, /* rb_logbook_size */
@ -80,7 +80,7 @@ static const mares_darwinair_layout_t mares_darwin_layout = {
2 /* samplesize */
};
static const mares_darwinair_layout_t mares_darwinair_layout = {
static const mares_darwin_layout_t mares_darwinair_layout = {
0x4000, /* memsize */
0x0100, /* rb_logbook_offset */
60, /* rb_logbook_size */
@ -91,29 +91,29 @@ static const mares_darwinair_layout_t mares_darwinair_layout = {
};
static int
device_is_mares_darwinair (device_t *abstract)
device_is_mares_darwin (device_t *abstract)
{
if (abstract == NULL)
return 0;
return abstract->backend == &mares_darwinair_device_backend;
return abstract->backend == &mares_darwin_device_backend;
}
device_status_t
mares_darwinair_device_open (device_t **out, const char* name, unsigned int model)
mares_darwin_device_open (device_t **out, const char* name, unsigned int model)
{
if (out == NULL)
return DEVICE_STATUS_ERROR;
// Allocate memory.
mares_darwinair_device_t *device = (mares_darwinair_device_t *) malloc (sizeof (mares_darwinair_device_t));
mares_darwin_device_t *device = (mares_darwin_device_t *) malloc (sizeof (mares_darwin_device_t));
if (device == NULL) {
WARNING ("Failed to allocate memory.");
return DEVICE_STATUS_MEMORY;
}
// Initialize the base class.
mares_common_device_init (&device->base, &mares_darwinair_device_backend);
mares_common_device_init (&device->base, &mares_darwin_device_backend);
// Set the default values.
memset (device->fingerprint, 0, sizeof (device->fingerprint));
@ -169,9 +169,9 @@ mares_darwinair_device_open (device_t **out, const char* name, unsigned int mode
}
static device_status_t
mares_darwinair_device_close (device_t *abstract)
mares_darwin_device_close (device_t *abstract)
{
mares_darwinair_device_t *device = (mares_darwinair_device_t *) abstract;
mares_darwin_device_t *device = (mares_darwin_device_t *) abstract;
// Close the device.
if (serial_close (device->base.port) == -1) {
@ -187,9 +187,9 @@ mares_darwinair_device_close (device_t *abstract)
static device_status_t
mares_darwinair_device_set_fingerprint (device_t *abstract, const unsigned char data[], unsigned int size)
mares_darwin_device_set_fingerprint (device_t *abstract, const unsigned char data[], unsigned int size)
{
mares_darwinair_device_t *device = (mares_darwinair_device_t *) abstract;
mares_darwin_device_t *device = (mares_darwin_device_t *) abstract;
if (size && size != sizeof (device->fingerprint))
return DEVICE_STATUS_ERROR;
@ -204,9 +204,9 @@ mares_darwinair_device_set_fingerprint (device_t *abstract, const unsigned char
static device_status_t
mares_darwinair_device_dump (device_t *abstract, dc_buffer_t *buffer)
mares_darwin_device_dump (device_t *abstract, dc_buffer_t *buffer)
{
mares_darwinair_device_t *device = (mares_darwinair_device_t *) abstract;
mares_darwin_device_t *device = (mares_darwin_device_t *) abstract;
assert (device->layout != NULL);
@ -223,9 +223,9 @@ mares_darwinair_device_dump (device_t *abstract, dc_buffer_t *buffer)
static device_status_t
mares_darwinair_device_foreach (device_t *abstract, dive_callback_t callback, void *userdata)
mares_darwin_device_foreach (device_t *abstract, dive_callback_t callback, void *userdata)
{
mares_darwinair_device_t *device = (mares_darwinair_device_t *) abstract;
mares_darwin_device_t *device = (mares_darwin_device_t *) abstract;
assert (device->layout != NULL);
@ -233,7 +233,7 @@ mares_darwinair_device_foreach (device_t *abstract, dive_callback_t callback, vo
if (buffer == NULL)
return DEVICE_STATUS_MEMORY;
device_status_t rc = mares_darwinair_device_dump (abstract, buffer);
device_status_t rc = mares_darwin_device_dump (abstract, buffer);
if (rc != DEVICE_STATUS_SUCCESS) {
dc_buffer_free (buffer);
return rc;
@ -247,7 +247,7 @@ mares_darwinair_device_foreach (device_t *abstract, dive_callback_t callback, vo
devinfo.serial = array_uint16_be (data + 8);
device_event_emit (abstract, DEVICE_EVENT_DEVINFO, &devinfo);
rc = mares_darwinair_extract_dives (abstract, dc_buffer_get_data (buffer),
rc = mares_darwin_extract_dives (abstract, dc_buffer_get_data (buffer),
dc_buffer_get_size (buffer), callback, userdata);
dc_buffer_free (buffer);
@ -257,16 +257,16 @@ mares_darwinair_device_foreach (device_t *abstract, dive_callback_t callback, vo
device_status_t
mares_darwinair_extract_dives (device_t *abstract, const unsigned char data[], unsigned int size, dive_callback_t callback, void *userdata)
mares_darwin_extract_dives (device_t *abstract, const unsigned char data[], unsigned int size, dive_callback_t callback, void *userdata)
{
mares_darwinair_device_t *device = (mares_darwinair_device_t *) abstract;
mares_darwin_device_t *device = (mares_darwin_device_t *) abstract;
if (!device_is_mares_darwinair (abstract))
if (!device_is_mares_darwin (abstract))
return DEVICE_STATUS_TYPE_MISMATCH;
assert (device->layout != NULL);
const mares_darwinair_layout_t *layout = device->layout;
const mares_darwin_layout_t *layout = device->layout;
// Get the profile pointer.
unsigned int eop = array_uint16_be (data + 0x8A);

12
src/mares_darwinair.h → src/mares_darwin.h
View File

@ -19,8 +19,8 @@
* MA 02110-1301 USA
*/
#ifndef MARES_DARWINAIR_H
#define MARES_DARWINAIR_H
#ifndef MARES_DARWIN_H
#define MARES_DARWIN_H
#include "device.h"
#include "parser.h"
@ -30,15 +30,15 @@ extern "C" {
#endif /* __cplusplus */
device_status_t
mares_darwinair_device_open (device_t **device, const char *name, unsigned int model);
mares_darwin_device_open (device_t **device, const char *name, unsigned int model);
device_status_t
mares_darwinair_extract_dives (device_t *device, const unsigned char data[], unsigned int size, dive_callback_t callback, void *userdata);
mares_darwin_extract_dives (device_t *device, const unsigned char data[], unsigned int size, dive_callback_t callback, void *userdata);
parser_status_t
mares_darwinair_parser_create (parser_t **parser, unsigned int model);
mares_darwin_parser_create (parser_t **parser, unsigned int model);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* MARES_DARWINAIR_H */
#endif /* MARES_DARWIN_H */

58
src/mares_darwinair_parser.c → src/mares_darwin_parser.c
View File

@ -22,7 +22,7 @@
#include <stdlib.h>
#include <string.h>
#include "mares_darwinair.h"
#include "mares_darwin.h"
#include "parser-private.h"
#include "units.h"
#include "utils.h"
@ -31,55 +31,55 @@
#define DARWIN 0
#define DARWINAIR 1
typedef struct mares_darwinair_parser_t mares_darwinair_parser_t;
typedef struct mares_darwin_parser_t mares_darwin_parser_t;
struct mares_darwinair_parser_t {
struct mares_darwin_parser_t {
parser_t base;
unsigned int headersize;
unsigned int samplesize;
};
static parser_status_t mares_darwinair_parser_set_data (parser_t *abstract, const unsigned char *data, unsigned int size);
static parser_status_t mares_darwinair_parser_get_datetime (parser_t *abstract, dc_datetime_t *datetime);
static parser_status_t mares_darwinair_parser_get_field (parser_t *abstract, parser_field_type_t type, unsigned int flags, void *value);
static parser_status_t mares_darwinair_parser_samples_foreach (parser_t *abstract, sample_callback_t callback, void *userdata);
static parser_status_t mares_darwinair_parser_destroy (parser_t *abstract);
static parser_status_t mares_darwin_parser_set_data (parser_t *abstract, const unsigned char *data, unsigned int size);
static parser_status_t mares_darwin_parser_get_datetime (parser_t *abstract, dc_datetime_t *datetime);
static parser_status_t mares_darwin_parser_get_field (parser_t *abstract, parser_field_type_t type, unsigned int flags, void *value);
static parser_status_t mares_darwin_parser_samples_foreach (parser_t *abstract, sample_callback_t callback, void *userdata);
static parser_status_t mares_darwin_parser_destroy (parser_t *abstract);
static const parser_backend_t mares_darwinair_parser_backend = {
PARSER_TYPE_MARES_DARWINAIR,
mares_darwinair_parser_set_data, /* set_data */
mares_darwinair_parser_get_datetime, /* datetime */
mares_darwinair_parser_get_field, /* fields */
mares_darwinair_parser_samples_foreach, /* samples_foreach */
mares_darwinair_parser_destroy /* destroy */
static const parser_backend_t mares_darwin_parser_backend = {
PARSER_TYPE_MARES_DARWIN,
mares_darwin_parser_set_data, /* set_data */
mares_darwin_parser_get_datetime, /* datetime */
mares_darwin_parser_get_field, /* fields */
mares_darwin_parser_samples_foreach, /* samples_foreach */
mares_darwin_parser_destroy /* destroy */
};
static int
parser_is_mares_darwinair (parser_t *abstract)
parser_is_mares_darwin (parser_t *abstract)
{
if (abstract == NULL)
return 0;
return abstract->backend == &mares_darwinair_parser_backend;
return abstract->backend == &mares_darwin_parser_backend;
}
parser_status_t
mares_darwinair_parser_create (parser_t **out, unsigned int model)
mares_darwin_parser_create (parser_t **out, unsigned int model)
{
if (out == NULL)
return PARSER_STATUS_ERROR;
// Allocate memory.
mares_darwinair_parser_t *parser = (mares_darwinair_parser_t *) malloc (sizeof (mares_darwinair_parser_t));
mares_darwin_parser_t *parser = (mares_darwin_parser_t *) malloc (sizeof (mares_darwin_parser_t));
if (parser == NULL) {
WARNING ("Failed to allocate memory.");
return PARSER_STATUS_MEMORY;
}
// Initialize the base class.
parser_init (&parser->base, &mares_darwinair_parser_backend);
parser_init (&parser->base, &mares_darwin_parser_backend);
if (model == DARWINAIR) {
parser->headersize = 60;
@ -96,9 +96,9 @@ mares_darwinair_parser_create (parser_t **out, unsigned int model)
static parser_status_t
mares_darwinair_parser_destroy (parser_t *abstract)
mares_darwin_parser_destroy (parser_t *abstract)
{
if (! parser_is_mares_darwinair (abstract))
if (! parser_is_mares_darwin (abstract))
return PARSER_STATUS_TYPE_MISMATCH;
// Free memory.
@ -109,16 +109,16 @@ mares_darwinair_parser_destroy (parser_t *abstract)
static parser_status_t
mares_darwinair_parser_set_data (parser_t *abstract, const unsigned char *data, unsigned int size)
mares_darwin_parser_set_data (parser_t *abstract, const unsigned char *data, unsigned int size)
{
return PARSER_STATUS_SUCCESS;
}
static parser_status_t
mares_darwinair_parser_get_datetime (parser_t *abstract, dc_datetime_t *datetime)
mares_darwin_parser_get_datetime (parser_t *abstract, dc_datetime_t *datetime)
{
mares_darwinair_parser_t *parser = (mares_darwinair_parser_t *) abstract;
mares_darwin_parser_t *parser = (mares_darwin_parser_t *) abstract;
if (abstract->size < parser->headersize)
return PARSER_STATUS_ERROR;
@ -139,9 +139,9 @@ mares_darwinair_parser_get_datetime (parser_t *abstract, dc_datetime_t *datetime
static parser_status_t
mares_darwinair_parser_get_field (parser_t *abstract, parser_field_type_t type, unsigned int flags, void *value)
mares_darwin_parser_get_field (parser_t *abstract, parser_field_type_t type, unsigned int flags, void *value)
{
mares_darwinair_parser_t *parser = (mares_darwinair_parser_t *) abstract;
mares_darwin_parser_t *parser = (mares_darwin_parser_t *) abstract;
if (abstract->size < parser->headersize)
return PARSER_STATUS_ERROR;
@ -176,9 +176,9 @@ mares_darwinair_parser_get_field (parser_t *abstract, parser_field_type_t type,
static parser_status_t
mares_darwinair_parser_samples_foreach (parser_t *abstract, sample_callback_t callback, void *userdata)
mares_darwin_parser_samples_foreach (parser_t *abstract, sample_callback_t callback, void *userdata)
{
mares_darwinair_parser_t *parser = (mares_darwinair_parser_t *) abstract;
mares_darwin_parser_t *parser = (mares_darwin_parser_t *) abstract;
if (abstract->size < parser->headersize)
return PARSER_STATUS_ERROR;

2
src/parser.h
View File

@ -40,7 +40,7 @@ typedef enum parser_type_t {
PARSER_TYPE_UWATEC_MEMOMOUSE,
PARSER_TYPE_UWATEC_SMART,
PARSER_TYPE_MARES_NEMO,
PARSER_TYPE_MARES_DARWINAIR,
PARSER_TYPE_MARES_DARWIN,
PARSER_TYPE_MARES_ICONHD,
PARSER_TYPE_OCEANIC_VTPRO,
PARSER_TYPE_OCEANIC_VEO250,