diff --git a/src/atomics_cobalt.c b/src/atomics_cobalt.c index 184c633..6bc3de2 100644 --- a/src/atomics_cobalt.c +++ b/src/atomics_cobalt.c @@ -69,6 +69,7 @@ static dc_status_t atomics_cobalt_device_foreach (dc_device_t *abstract, dc_dive static dc_status_t atomics_cobalt_device_close (dc_device_t *abstract); static const dc_device_vtable_t atomics_cobalt_device_vtable = { + sizeof(atomics_cobalt_device_t), DC_FAMILY_ATOMICS_COBALT, atomics_cobalt_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -92,15 +93,12 @@ atomics_cobalt_device_open (dc_device_t **out, dc_context_t *context) #ifdef HAVE_LIBUSB // Allocate memory. - device = (atomics_cobalt_device_t *) malloc (sizeof (atomics_cobalt_device_t)); + device = (atomics_cobalt_device_t *) dc_device_allocate (context, &atomics_cobalt_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &atomics_cobalt_device_vtable); - // Set the default values. device->context = NULL; device->handle = NULL; @@ -143,7 +141,7 @@ error_usb_close: error_usb_exit: libusb_exit (device->context); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; #else return DC_STATUS_UNSUPPORTED; diff --git a/src/atomics_cobalt_parser.c b/src/atomics_cobalt_parser.c index a14e539..4bfbcbb 100644 --- a/src/atomics_cobalt_parser.c +++ b/src/atomics_cobalt_parser.c @@ -50,6 +50,7 @@ static dc_status_t atomics_cobalt_parser_get_field (dc_parser_t *abstract, dc_fi static dc_status_t atomics_cobalt_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t atomics_cobalt_parser_vtable = { + sizeof(atomics_cobalt_parser_t), DC_FAMILY_ATOMICS_COBALT, atomics_cobalt_parser_set_data, /* set_data */ atomics_cobalt_parser_get_datetime, /* datetime */ @@ -62,19 +63,18 @@ static const dc_parser_vtable_t atomics_cobalt_parser_vtable = { dc_status_t atomics_cobalt_parser_create (dc_parser_t **out, dc_context_t *context) { + atomics_cobalt_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - atomics_cobalt_parser_t *parser = (atomics_cobalt_parser_t *) malloc (sizeof (atomics_cobalt_parser_t)); + parser = (atomics_cobalt_parser_t *) dc_parser_allocate (context, &atomics_cobalt_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &atomics_cobalt_parser_vtable); - // Set the default values. parser->atmospheric = 0.0; parser->hydrostatic = 1025.0 * GRAVITY; diff --git a/src/citizen_aqualand.c b/src/citizen_aqualand.c index dc3e9d7..774a3e4 100644 --- a/src/citizen_aqualand.c +++ b/src/citizen_aqualand.c @@ -50,6 +50,7 @@ static dc_status_t citizen_aqualand_device_foreach (dc_device_t *abstract, dc_di static dc_status_t citizen_aqualand_device_close (dc_device_t *abstract); static const dc_device_vtable_t citizen_aqualand_device_vtable = { + sizeof(citizen_aqualand_device_t), DC_FAMILY_CITIZEN_AQUALAND, citizen_aqualand_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -70,15 +71,12 @@ citizen_aqualand_device_open (dc_device_t **out, dc_context_t *context, const ch return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (citizen_aqualand_device_t *) malloc (sizeof (citizen_aqualand_device_t)); + device = (citizen_aqualand_device_t *) dc_device_allocate (context, &citizen_aqualand_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &citizen_aqualand_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -117,7 +115,7 @@ citizen_aqualand_device_open (dc_device_t **out, dc_context_t *context, const ch error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/citizen_aqualand_parser.c b/src/citizen_aqualand_parser.c index fd96c79..988375b 100644 --- a/src/citizen_aqualand_parser.c +++ b/src/citizen_aqualand_parser.c @@ -42,6 +42,7 @@ static dc_status_t citizen_aqualand_parser_get_field (dc_parser_t *abstract, dc_ static dc_status_t citizen_aqualand_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t citizen_aqualand_parser_vtable = { + sizeof(citizen_aqualand_parser_t), DC_FAMILY_CITIZEN_AQUALAND, citizen_aqualand_parser_set_data, /* set_data */ citizen_aqualand_parser_get_datetime, /* datetime */ @@ -54,19 +55,18 @@ static const dc_parser_vtable_t citizen_aqualand_parser_vtable = { dc_status_t citizen_aqualand_parser_create (dc_parser_t **out, dc_context_t *context) { + citizen_aqualand_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - citizen_aqualand_parser_t *parser = (citizen_aqualand_parser_t *) malloc (sizeof (citizen_aqualand_parser_t)); + parser = (citizen_aqualand_parser_t *) dc_parser_allocate (context, &citizen_aqualand_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &citizen_aqualand_parser_vtable); - *out = (dc_parser_t*) parser; return DC_STATUS_SUCCESS; diff --git a/src/cressi_edy.c b/src/cressi_edy.c index 3bc72c0..cfd5f9e 100644 --- a/src/cressi_edy.c +++ b/src/cressi_edy.c @@ -73,6 +73,7 @@ static dc_status_t cressi_edy_device_foreach (dc_device_t *abstract, dc_dive_cal static dc_status_t cressi_edy_device_close (dc_device_t *abstract); static const dc_device_vtable_t cressi_edy_device_vtable = { + sizeof(cressi_edy_device_t), DC_FAMILY_CRESSI_EDY, cressi_edy_device_set_fingerprint, /* set_fingerprint */ cressi_edy_device_read, /* read */ @@ -243,15 +244,12 @@ cressi_edy_device_open (dc_device_t **out, dc_context_t *context, const char *na return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (cressi_edy_device_t *) malloc (sizeof (cressi_edy_device_t)); + device = (cressi_edy_device_t *) dc_device_allocate (context, &cressi_edy_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &cressi_edy_device_vtable); - // Set the default values. device->port = NULL; device->layout = NULL; @@ -323,7 +321,7 @@ cressi_edy_device_open (dc_device_t **out, dc_context_t *context, const char *na error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/cressi_edy_parser.c b/src/cressi_edy_parser.c index 6777081..06296f7 100644 --- a/src/cressi_edy_parser.c +++ b/src/cressi_edy_parser.c @@ -45,6 +45,7 @@ static dc_status_t cressi_edy_parser_get_field (dc_parser_t *abstract, dc_field_ static dc_status_t cressi_edy_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t cressi_edy_parser_vtable = { + sizeof(cressi_edy_parser_t), DC_FAMILY_CRESSI_EDY, cressi_edy_parser_set_data, /* set_data */ cressi_edy_parser_get_datetime, /* datetime */ @@ -72,19 +73,18 @@ cressi_edy_parser_count_gasmixes (const unsigned char *data) dc_status_t cressi_edy_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + cressi_edy_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - cressi_edy_parser_t *parser = (cressi_edy_parser_t *) malloc (sizeof (cressi_edy_parser_t)); + parser = (cressi_edy_parser_t *) dc_parser_allocate (context, &cressi_edy_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &cressi_edy_parser_vtable); - // Set the default values. parser->model = model; diff --git a/src/cressi_leonardo.c b/src/cressi_leonardo.c index 2c9045e..40a6630 100644 --- a/src/cressi_leonardo.c +++ b/src/cressi_leonardo.c @@ -62,6 +62,7 @@ static dc_status_t cressi_leonardo_device_foreach (dc_device_t *abstract, dc_div static dc_status_t cressi_leonardo_device_close (dc_device_t *abstract); static const dc_device_vtable_t cressi_leonardo_device_vtable = { + sizeof(cressi_leonardo_device_t), DC_FAMILY_CRESSI_LEONARDO, cressi_leonardo_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -81,15 +82,12 @@ cressi_leonardo_device_open (dc_device_t **out, dc_context_t *context, const cha return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (cressi_leonardo_device_t *) malloc (sizeof (cressi_leonardo_device_t)); + device = (cressi_leonardo_device_t *) dc_device_allocate (context, &cressi_leonardo_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &cressi_leonardo_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -135,7 +133,7 @@ cressi_leonardo_device_open (dc_device_t **out, dc_context_t *context, const cha error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/cressi_leonardo_parser.c b/src/cressi_leonardo_parser.c index ceced18..d9ed79c 100644 --- a/src/cressi_leonardo_parser.c +++ b/src/cressi_leonardo_parser.c @@ -43,6 +43,7 @@ static dc_status_t cressi_leonardo_parser_get_field (dc_parser_t *abstract, dc_f static dc_status_t cressi_leonardo_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t cressi_leonardo_parser_vtable = { + sizeof(cressi_leonardo_parser_t), DC_FAMILY_CRESSI_EDY, cressi_leonardo_parser_set_data, /* set_data */ cressi_leonardo_parser_get_datetime, /* datetime */ @@ -55,19 +56,18 @@ static const dc_parser_vtable_t cressi_leonardo_parser_vtable = { dc_status_t cressi_leonardo_parser_create (dc_parser_t **out, dc_context_t *context) { + cressi_leonardo_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - cressi_leonardo_parser_t *parser = (cressi_leonardo_parser_t *) malloc (sizeof (cressi_leonardo_parser_t)); + parser = (cressi_leonardo_parser_t *) dc_parser_allocate (context, &cressi_leonardo_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &cressi_leonardo_parser_vtable); - *out = (dc_parser_t*) parser; return DC_STATUS_SUCCESS; diff --git a/src/device-private.h b/src/device-private.h index 9254c6c..dcf0b96 100644 --- a/src/device-private.h +++ b/src/device-private.h @@ -57,6 +57,8 @@ struct dc_device_t { }; struct dc_device_vtable_t { + size_t size; + dc_family_t type; dc_status_t (*set_fingerprint) (dc_device_t *device, const unsigned char data[], unsigned int size); @@ -75,8 +77,11 @@ struct dc_device_vtable_t { int dc_device_isinstance (dc_device_t *device, const dc_device_vtable_t *vtable); +dc_device_t * +dc_device_allocate (dc_context_t *context, const dc_device_vtable_t *vtable); + void -device_init (dc_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable); +dc_device_deallocate (dc_device_t *device); void device_event_emit (dc_device_t *device, dc_event_type_t event, const void *data); diff --git a/src/device.c b/src/device.c index 8758480..31ec8b8 100644 --- a/src/device.c +++ b/src/device.c @@ -40,10 +40,21 @@ #include "device-private.h" #include "context-private.h" - -void -device_init (dc_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable) +dc_device_t * +dc_device_allocate (dc_context_t *context, const dc_device_vtable_t *vtable) { + dc_device_t *device = NULL; + + assert(vtable != NULL); + assert(vtable->size >= sizeof(dc_device_t)); + + // Allocate memory. + device = (dc_device_t *) malloc (vtable->size); + if (device == NULL) { + ERROR (context, "Failed to allocate memory."); + return device; + } + device->vtable = vtable; device->context = context; @@ -57,6 +68,14 @@ device_init (dc_device_t *device, dc_context_t *context, const dc_device_vtable_ memset (&device->devinfo, 0, sizeof (device->devinfo)); memset (&device->clock, 0, sizeof (device->clock)); + + return device; +} + +void +dc_device_deallocate (dc_device_t *device) +{ + free (device); } dc_status_t @@ -340,7 +359,7 @@ dc_device_close (dc_device_t *device) status = device->vtable->close (device); } - free (device); + dc_device_deallocate (device); return status; } diff --git a/src/diverite_nitekq.c b/src/diverite_nitekq.c index fc819a1..a873424 100644 --- a/src/diverite_nitekq.c +++ b/src/diverite_nitekq.c @@ -68,6 +68,7 @@ static dc_status_t diverite_nitekq_device_foreach (dc_device_t *abstract, dc_div static dc_status_t diverite_nitekq_device_close (dc_device_t *abstract); static const dc_device_vtable_t diverite_nitekq_device_vtable = { + sizeof(diverite_nitekq_device_t), DC_FAMILY_DIVERITE_NITEKQ, diverite_nitekq_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -156,15 +157,12 @@ diverite_nitekq_device_open (dc_device_t **out, dc_context_t *context, const cha return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (diverite_nitekq_device_t *) malloc (sizeof (diverite_nitekq_device_t)); + device = (diverite_nitekq_device_t *) dc_device_allocate (context, &diverite_nitekq_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &diverite_nitekq_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -210,7 +208,7 @@ diverite_nitekq_device_open (dc_device_t **out, dc_context_t *context, const cha error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/diverite_nitekq_parser.c b/src/diverite_nitekq_parser.c index a32efa1..460dcbf 100644 --- a/src/diverite_nitekq_parser.c +++ b/src/diverite_nitekq_parser.c @@ -54,6 +54,7 @@ static dc_status_t diverite_nitekq_parser_get_field (dc_parser_t *abstract, dc_f static dc_status_t diverite_nitekq_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t diverite_nitekq_parser_vtable = { + sizeof(diverite_nitekq_parser_t), DC_FAMILY_DIVERITE_NITEKQ, diverite_nitekq_parser_set_data, /* set_data */ diverite_nitekq_parser_get_datetime, /* datetime */ @@ -66,19 +67,18 @@ static const dc_parser_vtable_t diverite_nitekq_parser_vtable = { dc_status_t diverite_nitekq_parser_create (dc_parser_t **out, dc_context_t *context) { + diverite_nitekq_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - diverite_nitekq_parser_t *parser = (diverite_nitekq_parser_t *) malloc (sizeof (diverite_nitekq_parser_t)); + parser = (diverite_nitekq_parser_t *) dc_parser_allocate (context, &diverite_nitekq_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &diverite_nitekq_parser_vtable); - // Set the default values. parser->cached = 0; parser->metric = 0; diff --git a/src/divesystem_idive.c b/src/divesystem_idive.c index 9565386..e48e47b 100644 --- a/src/divesystem_idive.c +++ b/src/divesystem_idive.c @@ -77,6 +77,7 @@ static dc_status_t divesystem_idive_device_foreach (dc_device_t *abstract, dc_di static dc_status_t divesystem_idive_device_close (dc_device_t *abstract); static const dc_device_vtable_t divesystem_idive_device_vtable = { + sizeof(divesystem_idive_device_t), DC_FAMILY_DIVESYSTEM_IDIVE, divesystem_idive_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -117,15 +118,12 @@ divesystem_idive_device_open2 (dc_device_t **out, dc_context_t *context, const c return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (divesystem_idive_device_t *) malloc (sizeof (divesystem_idive_device_t)); + device = (divesystem_idive_device_t *) dc_device_allocate (context, &divesystem_idive_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &divesystem_idive_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -165,7 +163,7 @@ divesystem_idive_device_open2 (dc_device_t **out, dc_context_t *context, const c error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/divesystem_idive_parser.c b/src/divesystem_idive_parser.c index 5ea2052..64454a8 100644 --- a/src/divesystem_idive_parser.c +++ b/src/divesystem_idive_parser.c @@ -64,6 +64,7 @@ static dc_status_t divesystem_idive_parser_get_field (dc_parser_t *abstract, dc_ static dc_status_t divesystem_idive_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t divesystem_idive_parser_vtable = { + sizeof(divesystem_idive_parser_t), DC_FAMILY_DIVESYSTEM_IDIVE, divesystem_idive_parser_set_data, /* set_data */ divesystem_idive_parser_get_datetime, /* datetime */ @@ -83,19 +84,18 @@ divesystem_idive_parser_create (dc_parser_t **out, dc_context_t *context) dc_status_t divesystem_idive_parser_create2 (dc_parser_t **out, dc_context_t *context, unsigned int model) { + divesystem_idive_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - divesystem_idive_parser_t *parser = (divesystem_idive_parser_t *) malloc (sizeof (divesystem_idive_parser_t)); + parser = (divesystem_idive_parser_t *) dc_parser_allocate (context, &divesystem_idive_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &divesystem_idive_parser_vtable); - // Set the default values. if (model >= IX3M_EASY && model <= IX3M_REB) { parser->headersize = SZ_HEADER_IX3M; diff --git a/src/hw_frog.c b/src/hw_frog.c index 339c5ef..511052c 100644 --- a/src/hw_frog.c +++ b/src/hw_frog.c @@ -70,6 +70,7 @@ static dc_status_t hw_frog_device_foreach (dc_device_t *abstract, dc_dive_callba static dc_status_t hw_frog_device_close (dc_device_t *abstract); static const dc_device_vtable_t hw_frog_device_vtable = { + sizeof(hw_frog_device_t), DC_FAMILY_HW_FROG, hw_frog_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -209,15 +210,12 @@ hw_frog_device_open (dc_device_t **out, dc_context_t *context, const char *name) return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (hw_frog_device_t *) malloc (sizeof (hw_frog_device_t)); + device = (hw_frog_device_t *) dc_device_allocate (context, &hw_frog_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &hw_frog_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -263,7 +261,7 @@ hw_frog_device_open (dc_device_t **out, dc_context_t *context, const char *name) error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/hw_ostc.c b/src/hw_ostc.c index d69c3df..6a6c3d7 100644 --- a/src/hw_ostc.c +++ b/src/hw_ostc.c @@ -79,6 +79,7 @@ static dc_status_t hw_ostc_device_foreach (dc_device_t *abstract, dc_dive_callba static dc_status_t hw_ostc_device_close (dc_device_t *abstract); static const dc_device_vtable_t hw_ostc_device_vtable = { + sizeof(hw_ostc_device_t), DC_FAMILY_HW_OSTC, hw_ostc_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -132,15 +133,12 @@ hw_ostc_device_open (dc_device_t **out, dc_context_t *context, const char *name) return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (hw_ostc_device_t *) malloc (sizeof (hw_ostc_device_t)); + device = (hw_ostc_device_t *) dc_device_allocate (context, &hw_ostc_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &hw_ostc_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -179,7 +177,7 @@ hw_ostc_device_open (dc_device_t **out, dc_context_t *context, const char *name) error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/hw_ostc3.c b/src/hw_ostc3.c index a2befa0..9b81055 100644 --- a/src/hw_ostc3.c +++ b/src/hw_ostc3.c @@ -123,6 +123,7 @@ static dc_status_t hw_ostc3_device_foreach (dc_device_t *abstract, dc_dive_callb static dc_status_t hw_ostc3_device_close (dc_device_t *abstract); static const dc_device_vtable_t hw_ostc3_device_vtable = { + sizeof(hw_ostc3_device_t), DC_FAMILY_HW_OSTC3, hw_ostc3_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -282,15 +283,12 @@ hw_ostc3_device_open (dc_device_t **out, dc_context_t *context, const char *name return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (hw_ostc3_device_t *) malloc (sizeof (hw_ostc3_device_t)); + device = (hw_ostc3_device_t *) dc_device_allocate (context, &hw_ostc3_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &hw_ostc3_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -331,7 +329,7 @@ hw_ostc3_device_open (dc_device_t **out, dc_context_t *context, const char *name error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/hw_ostc_parser.c b/src/hw_ostc_parser.c index 5ee2097..abc42ba 100644 --- a/src/hw_ostc_parser.c +++ b/src/hw_ostc_parser.c @@ -99,6 +99,7 @@ static dc_status_t hw_ostc_parser_get_field (dc_parser_t *abstract, dc_field_typ static dc_status_t hw_ostc_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t hw_ostc_parser_vtable = { + sizeof(hw_ostc_parser_t), DC_FAMILY_HW_OSTC, hw_ostc_parser_set_data, /* set_data */ hw_ostc_parser_get_datetime, /* datetime */ @@ -266,19 +267,18 @@ hw_ostc_parser_cache (hw_ostc_parser_t *parser) dc_status_t hw_ostc_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int frog) { + hw_ostc_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - hw_ostc_parser_t *parser = (hw_ostc_parser_t *) malloc (sizeof (hw_ostc_parser_t)); + parser = (hw_ostc_parser_t *) dc_parser_allocate (context, &hw_ostc_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &hw_ostc_parser_vtable); - // Set the default values. parser->frog = frog; parser->cached = 0; diff --git a/src/mares_common.c b/src/mares_common.c index 669de99..6f0c3dd 100644 --- a/src/mares_common.c +++ b/src/mares_common.c @@ -52,13 +52,10 @@ #define GAUGE 3 void -mares_common_device_init (mares_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable) +mares_common_device_init (mares_common_device_t *device) { assert (device != NULL); - // Initialize the base class. - device_init (&device->base, context, vtable); - // Set the default values. device->port = NULL; device->echo = 0; diff --git a/src/mares_common.h b/src/mares_common.h index 14eeae3..33228c5 100644 --- a/src/mares_common.h +++ b/src/mares_common.h @@ -47,7 +47,7 @@ typedef struct mares_common_device_t { } mares_common_device_t; void -mares_common_device_init (mares_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable); +mares_common_device_init (mares_common_device_t *device); dc_status_t mares_common_device_read (dc_device_t *abstract, unsigned int address, unsigned char data[], unsigned int size); diff --git a/src/mares_darwin.c b/src/mares_darwin.c index d12172f..f8a39d9 100644 --- a/src/mares_darwin.c +++ b/src/mares_darwin.c @@ -63,6 +63,7 @@ static dc_status_t mares_darwin_device_foreach (dc_device_t *abstract, dc_dive_c static dc_status_t mares_darwin_device_close (dc_device_t *abstract); static const dc_device_vtable_t mares_darwin_device_vtable = { + sizeof(mares_darwin_device_t), DC_FAMILY_MARES_DARWIN, mares_darwin_device_set_fingerprint, /* set_fingerprint */ mares_common_device_read, /* read */ @@ -103,14 +104,14 @@ mares_darwin_device_open (dc_device_t **out, dc_context_t *context, const char * return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (mares_darwin_device_t *) malloc (sizeof (mares_darwin_device_t)); + device = (mares_darwin_device_t *) dc_device_allocate (context, &mares_darwin_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - mares_common_device_init (&device->base, context, &mares_darwin_device_vtable); + mares_common_device_init (&device->base); // Set the default values. memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -166,7 +167,7 @@ mares_darwin_device_open (dc_device_t **out, dc_context_t *context, const char * error_close: serial_close (device->base.port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/mares_darwin_parser.c b/src/mares_darwin_parser.c index 67ae51c..42cccb4 100644 --- a/src/mares_darwin_parser.c +++ b/src/mares_darwin_parser.c @@ -49,6 +49,7 @@ static dc_status_t mares_darwin_parser_get_field (dc_parser_t *abstract, dc_fiel static dc_status_t mares_darwin_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t mares_darwin_parser_vtable = { + sizeof(mares_darwin_parser_t), DC_FAMILY_MARES_DARWIN, mares_darwin_parser_set_data, /* set_data */ mares_darwin_parser_get_datetime, /* datetime */ @@ -61,19 +62,18 @@ static const dc_parser_vtable_t mares_darwin_parser_vtable = { dc_status_t mares_darwin_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + mares_darwin_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - mares_darwin_parser_t *parser = (mares_darwin_parser_t *) malloc (sizeof (mares_darwin_parser_t)); + parser = (mares_darwin_parser_t *) dc_parser_allocate (context, &mares_darwin_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &mares_darwin_parser_vtable); - parser->model = model; if (model == DARWINAIR) { diff --git a/src/mares_iconhd.c b/src/mares_iconhd.c index 123b103..79dda55 100644 --- a/src/mares_iconhd.c +++ b/src/mares_iconhd.c @@ -84,6 +84,7 @@ static dc_status_t mares_iconhd_device_foreach (dc_device_t *abstract, dc_dive_c static dc_status_t mares_iconhd_device_close (dc_device_t *abstract); static const dc_device_vtable_t mares_iconhd_device_vtable = { + sizeof(mares_iconhd_device_t), DC_FAMILY_MARES_ICONHD, mares_iconhd_device_set_fingerprint, /* set_fingerprint */ mares_iconhd_device_read, /* read */ @@ -221,15 +222,12 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, const char * return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (mares_iconhd_device_t *) malloc (sizeof (mares_iconhd_device_t)); + device = (mares_iconhd_device_t *) dc_device_allocate (context, &mares_iconhd_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &mares_iconhd_device_vtable); - // Set the default values. device->port = NULL; device->layout = NULL; @@ -316,7 +314,7 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, const char * error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/mares_iconhd_parser.c b/src/mares_iconhd_parser.c index 728162e..8789a71 100644 --- a/src/mares_iconhd_parser.c +++ b/src/mares_iconhd_parser.c @@ -62,6 +62,7 @@ static dc_status_t mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_fiel static dc_status_t mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t mares_iconhd_parser_vtable = { + sizeof(mares_iconhd_parser_t), DC_FAMILY_MARES_ICONHD, mares_iconhd_parser_set_data, /* set_data */ mares_iconhd_parser_get_datetime, /* datetime */ @@ -197,19 +198,18 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser) dc_status_t mares_iconhd_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + mares_iconhd_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - mares_iconhd_parser_t *parser = (mares_iconhd_parser_t *) malloc (sizeof (mares_iconhd_parser_t)); + parser = (mares_iconhd_parser_t *) dc_parser_allocate (context, &mares_iconhd_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &mares_iconhd_parser_vtable); - // Set the default values. parser->model = model; parser->cached = 0; diff --git a/src/mares_nemo.c b/src/mares_nemo.c index e6a1bb8..7f71dbf 100644 --- a/src/mares_nemo.c +++ b/src/mares_nemo.c @@ -61,6 +61,7 @@ static dc_status_t mares_nemo_device_foreach (dc_device_t *abstract, dc_dive_cal static dc_status_t mares_nemo_device_close (dc_device_t *abstract); static const dc_device_vtable_t mares_nemo_device_vtable = { + sizeof(mares_nemo_device_t), DC_FAMILY_MARES_NEMO, mares_nemo_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -97,15 +98,12 @@ mares_nemo_device_open (dc_device_t **out, dc_context_t *context, const char *na return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (mares_nemo_device_t *) malloc (sizeof (mares_nemo_device_t)); + device = (mares_nemo_device_t *) dc_device_allocate (context, &mares_nemo_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &mares_nemo_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -151,7 +149,7 @@ mares_nemo_device_open (dc_device_t **out, dc_context_t *context, const char *na error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/mares_nemo_parser.c b/src/mares_nemo_parser.c index 487b5f2..33e5916 100644 --- a/src/mares_nemo_parser.c +++ b/src/mares_nemo_parser.c @@ -65,6 +65,7 @@ static dc_status_t mares_nemo_parser_get_field (dc_parser_t *abstract, dc_field_ static dc_status_t mares_nemo_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t mares_nemo_parser_vtable = { + sizeof(mares_nemo_parser_t), DC_FAMILY_MARES_NEMO, mares_nemo_parser_set_data, /* set_data */ mares_nemo_parser_get_datetime, /* datetime */ @@ -77,19 +78,18 @@ static const dc_parser_vtable_t mares_nemo_parser_vtable = { dc_status_t mares_nemo_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + mares_nemo_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - mares_nemo_parser_t *parser = (mares_nemo_parser_t *) malloc (sizeof (mares_nemo_parser_t)); + parser = (mares_nemo_parser_t *) dc_parser_allocate (context, &mares_nemo_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &mares_nemo_parser_vtable); - // Get the freedive mode for this model. unsigned int freedive = FREEDIVE; if (model == NEMOWIDE || model == NEMOAIR || model == PUCK || model == PUCKAIR) diff --git a/src/mares_puck.c b/src/mares_puck.c index 95ba855..67666df 100644 --- a/src/mares_puck.c +++ b/src/mares_puck.c @@ -51,6 +51,7 @@ static dc_status_t mares_puck_device_foreach (dc_device_t *abstract, dc_dive_cal static dc_status_t mares_puck_device_close (dc_device_t *abstract); static const dc_device_vtable_t mares_puck_device_vtable = { + sizeof(mares_puck_device_t), DC_FAMILY_MARES_PUCK, mares_puck_device_set_fingerprint, /* set_fingerprint */ mares_common_device_read, /* read */ @@ -95,14 +96,14 @@ mares_puck_device_open (dc_device_t **out, dc_context_t *context, const char *na return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (mares_puck_device_t *) malloc (sizeof (mares_puck_device_t)); + device = (mares_puck_device_t *) dc_device_allocate (context, &mares_puck_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - mares_common_device_init (&device->base, context, &mares_puck_device_vtable); + mares_common_device_init (&device->base); // Set the default values. device->layout = NULL; @@ -173,7 +174,7 @@ mares_puck_device_open (dc_device_t **out, dc_context_t *context, const char *na error_close: serial_close (device->base.port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/oceanic_atom2.c b/src/oceanic_atom2.c index 93aa5da..d19d82a 100644 --- a/src/oceanic_atom2.c +++ b/src/oceanic_atom2.c @@ -71,6 +71,7 @@ static dc_status_t oceanic_atom2_device_write (dc_device_t *abstract, unsigned i static dc_status_t oceanic_atom2_device_close (dc_device_t *abstract); static const dc_device_vtable_t oceanic_atom2_device_vtable = { + sizeof(oceanic_atom2_device_t), DC_FAMILY_OCEANIC_ATOM2, oceanic_common_device_set_fingerprint, /* set_fingerprint */ oceanic_atom2_device_read, /* read */ @@ -528,14 +529,14 @@ oceanic_atom2_device_open2 (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (oceanic_atom2_device_t *) malloc (sizeof (oceanic_atom2_device_t)); + device = (oceanic_atom2_device_t *) dc_device_allocate (context, &oceanic_atom2_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - oceanic_common_device_init (&device->base, context, &oceanic_atom2_device_vtable); + oceanic_common_device_init (&device->base); // Set the default values. device->port = NULL; @@ -643,7 +644,7 @@ oceanic_atom2_device_open2 (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/oceanic_atom2_parser.c b/src/oceanic_atom2_parser.c index a6f39ec..54188c2 100644 --- a/src/oceanic_atom2_parser.c +++ b/src/oceanic_atom2_parser.c @@ -109,6 +109,7 @@ static dc_status_t oceanic_atom2_parser_get_field (dc_parser_t *abstract, dc_fie static dc_status_t oceanic_atom2_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t oceanic_atom2_parser_vtable = { + sizeof(oceanic_atom2_parser_t), DC_FAMILY_OCEANIC_ATOM2, oceanic_atom2_parser_set_data, /* set_data */ oceanic_atom2_parser_get_datetime, /* datetime */ @@ -121,19 +122,18 @@ static const dc_parser_vtable_t oceanic_atom2_parser_vtable = { dc_status_t oceanic_atom2_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + oceanic_atom2_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - oceanic_atom2_parser_t *parser = (oceanic_atom2_parser_t *) malloc (sizeof (oceanic_atom2_parser_t)); + parser = (oceanic_atom2_parser_t *) dc_parser_allocate (context, &oceanic_atom2_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &oceanic_atom2_parser_vtable); - // Set the default values. parser->model = model; parser->headersize = 9 * PAGESIZE / 2; diff --git a/src/oceanic_common.c b/src/oceanic_common.c index f204309..a1d11fa 100644 --- a/src/oceanic_common.c +++ b/src/oceanic_common.c @@ -125,13 +125,10 @@ oceanic_common_match (const unsigned char *version, const oceanic_common_version void -oceanic_common_device_init (oceanic_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable) +oceanic_common_device_init (oceanic_common_device_t *device) { assert (device != NULL); - // Initialize the base class. - device_init (&device->base, context, vtable); - // Set the default values. memset (device->version, 0, sizeof (device->version)); memset (device->fingerprint, 0, sizeof (device->fingerprint)); diff --git a/src/oceanic_common.h b/src/oceanic_common.h index a9286aa..e5e53f0 100644 --- a/src/oceanic_common.h +++ b/src/oceanic_common.h @@ -71,7 +71,7 @@ int oceanic_common_match (const unsigned char *version, const oceanic_common_version_t patterns[], unsigned int n); void -oceanic_common_device_init (oceanic_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable); +oceanic_common_device_init (oceanic_common_device_t *device); dc_status_t oceanic_common_device_set_fingerprint (dc_device_t *device, const unsigned char data[], unsigned int size); diff --git a/src/oceanic_veo250.c b/src/oceanic_veo250.c index 15d8070..653d51e 100644 --- a/src/oceanic_veo250.c +++ b/src/oceanic_veo250.c @@ -54,6 +54,7 @@ static dc_status_t oceanic_veo250_device_read (dc_device_t *abstract, unsigned i static dc_status_t oceanic_veo250_device_close (dc_device_t *abstract); static const dc_device_vtable_t oceanic_veo250_device_vtable = { + sizeof(oceanic_veo250_device_t), DC_FAMILY_OCEANIC_VEO250, oceanic_common_device_set_fingerprint, /* set_fingerprint */ oceanic_veo250_device_read, /* read */ @@ -228,14 +229,14 @@ oceanic_veo250_device_open (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (oceanic_veo250_device_t *) malloc (sizeof (oceanic_veo250_device_t)); + device = (oceanic_veo250_device_t *) dc_device_allocate (context, &oceanic_veo250_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - oceanic_common_device_init (&device->base, context, &oceanic_veo250_device_vtable); + oceanic_common_device_init (&device->base); // Override the base class values. device->base.layout = &oceanic_veo250_layout; @@ -306,7 +307,7 @@ oceanic_veo250_device_open (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/oceanic_veo250_parser.c b/src/oceanic_veo250_parser.c index 4cc8ebe..a300af8 100644 --- a/src/oceanic_veo250_parser.c +++ b/src/oceanic_veo250_parser.c @@ -53,6 +53,7 @@ static dc_status_t oceanic_veo250_parser_get_field (dc_parser_t *abstract, dc_fi static dc_status_t oceanic_veo250_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t oceanic_veo250_parser_vtable = { + sizeof(oceanic_veo250_parser_t), DC_FAMILY_OCEANIC_VEO250, oceanic_veo250_parser_set_data, /* set_data */ oceanic_veo250_parser_get_datetime, /* datetime */ @@ -65,19 +66,18 @@ static const dc_parser_vtable_t oceanic_veo250_parser_vtable = { dc_status_t oceanic_veo250_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + oceanic_veo250_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - oceanic_veo250_parser_t *parser = (oceanic_veo250_parser_t *) malloc (sizeof (oceanic_veo250_parser_t)); + parser = (oceanic_veo250_parser_t *) dc_parser_allocate (context, &oceanic_veo250_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &oceanic_veo250_parser_vtable); - // Set the default values. parser->model = model; parser->cached = 0; diff --git a/src/oceanic_vtpro.c b/src/oceanic_vtpro.c index 67867b7..040f23f 100644 --- a/src/oceanic_vtpro.c +++ b/src/oceanic_vtpro.c @@ -54,6 +54,7 @@ static dc_status_t oceanic_vtpro_device_read (dc_device_t *abstract, unsigned in static dc_status_t oceanic_vtpro_device_close (dc_device_t *abstract); static const dc_device_vtable_t oceanic_vtpro_device_vtable = { + sizeof(oceanic_vtpro_device_t), DC_FAMILY_OCEANIC_VTPRO, oceanic_common_device_set_fingerprint, /* set_fingerprint */ oceanic_vtpro_device_read, /* read */ @@ -261,14 +262,14 @@ oceanic_vtpro_device_open (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (oceanic_vtpro_device_t *) malloc (sizeof (oceanic_vtpro_device_t)); + device = (oceanic_vtpro_device_t *) dc_device_allocate (context, &oceanic_vtpro_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - oceanic_common_device_init (&device->base, context, &oceanic_vtpro_device_vtable); + oceanic_common_device_init (&device->base); // Override the base class values. device->base.multipage = MULTIPAGE; @@ -349,7 +350,7 @@ oceanic_vtpro_device_open (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/oceanic_vtpro_parser.c b/src/oceanic_vtpro_parser.c index c1b5150..d2d7919 100644 --- a/src/oceanic_vtpro_parser.c +++ b/src/oceanic_vtpro_parser.c @@ -47,6 +47,7 @@ static dc_status_t oceanic_vtpro_parser_get_field (dc_parser_t *abstract, dc_fie static dc_status_t oceanic_vtpro_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t oceanic_vtpro_parser_vtable = { + sizeof(oceanic_vtpro_parser_t), DC_FAMILY_OCEANIC_VTPRO, oceanic_vtpro_parser_set_data, /* set_data */ oceanic_vtpro_parser_get_datetime, /* datetime */ @@ -59,19 +60,18 @@ static const dc_parser_vtable_t oceanic_vtpro_parser_vtable = { dc_status_t oceanic_vtpro_parser_create (dc_parser_t **out, dc_context_t *context) { + oceanic_vtpro_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - oceanic_vtpro_parser_t *parser = (oceanic_vtpro_parser_t *) malloc (sizeof (oceanic_vtpro_parser_t)); + parser = (oceanic_vtpro_parser_t *) dc_parser_allocate (context, &oceanic_vtpro_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &oceanic_vtpro_parser_vtable); - // Set the default values. parser->cached = 0; parser->divetime = 0; diff --git a/src/parser-private.h b/src/parser-private.h index 63f0f4f..eed9d51 100644 --- a/src/parser-private.h +++ b/src/parser-private.h @@ -42,6 +42,8 @@ struct dc_parser_t { }; struct dc_parser_vtable_t { + size_t size; + dc_family_t type; dc_status_t (*set_data) (dc_parser_t *parser, const unsigned char *data, unsigned int size); @@ -55,8 +57,11 @@ struct dc_parser_vtable_t { dc_status_t (*destroy) (dc_parser_t *parser); }; +dc_parser_t * +dc_parser_allocate (dc_context_t *context, const dc_parser_vtable_t *vtable); + void -parser_init (dc_parser_t *parser, dc_context_t *context, const dc_parser_vtable_t *vtable); +dc_parser_deallocate (dc_parser_t *parser); int dc_parser_isinstance (dc_parser_t *parser, const dc_parser_vtable_t *vtable); diff --git a/src/parser.c b/src/parser.c index bc6b406..5fb790f 100644 --- a/src/parser.c +++ b/src/parser.c @@ -20,6 +20,7 @@ */ #include +#include #include #include @@ -35,6 +36,7 @@ #include #include +#include "context-private.h" #include "parser-private.h" #include "device-private.h" @@ -152,15 +154,35 @@ dc_parser_new (dc_parser_t **out, dc_device_t *device) } -void -parser_init (dc_parser_t *parser, dc_context_t *context, const dc_parser_vtable_t *vtable) +dc_parser_t * +dc_parser_allocate (dc_context_t *context, const dc_parser_vtable_t *vtable) { + dc_parser_t *parser = NULL; + + assert(vtable != NULL); + assert(vtable->size >= sizeof(dc_parser_t)); + + // Allocate memory. + parser = (dc_parser_t *) malloc (vtable->size); + if (parser == NULL) { + ERROR (context, "Failed to allocate memory."); + return parser; + } + + // Initialize the base class. parser->vtable = vtable; parser->context = context; parser->data = NULL; parser->size = 0; + + return parser; } +void +dc_parser_deallocate (dc_parser_t *parser) +{ + free (parser); +} int dc_parser_isinstance (dc_parser_t *parser, const dc_parser_vtable_t *vtable) @@ -248,7 +270,7 @@ dc_parser_destroy (dc_parser_t *parser) status = parser->vtable->destroy (parser); } - free (parser); + dc_parser_deallocate (parser); return status; } diff --git a/src/reefnet_sensus.c b/src/reefnet_sensus.c index ba40ee5..0660155 100644 --- a/src/reefnet_sensus.c +++ b/src/reefnet_sensus.c @@ -56,6 +56,7 @@ static dc_status_t reefnet_sensus_device_foreach (dc_device_t *abstract, dc_dive static dc_status_t reefnet_sensus_device_close (dc_device_t *abstract); static const dc_device_vtable_t reefnet_sensus_device_vtable = { + sizeof(reefnet_sensus_device_t), DC_FAMILY_REEFNET_SENSUS, reefnet_sensus_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -96,15 +97,12 @@ reefnet_sensus_device_open (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (reefnet_sensus_device_t *) malloc (sizeof (reefnet_sensus_device_t)); + device = (reefnet_sensus_device_t *) dc_device_allocate (context, &reefnet_sensus_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &reefnet_sensus_device_vtable); - // Set the default values. device->port = NULL; device->waiting = 0; @@ -146,7 +144,7 @@ reefnet_sensus_device_open (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/reefnet_sensus_parser.c b/src/reefnet_sensus_parser.c index b5702f2..ba4b7de 100644 --- a/src/reefnet_sensus_parser.c +++ b/src/reefnet_sensus_parser.c @@ -54,6 +54,7 @@ static dc_status_t reefnet_sensus_parser_get_field (dc_parser_t *abstract, dc_fi static dc_status_t reefnet_sensus_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t reefnet_sensus_parser_vtable = { + sizeof(reefnet_sensus_parser_t), DC_FAMILY_REEFNET_SENSUS, reefnet_sensus_parser_set_data, /* set_data */ reefnet_sensus_parser_get_datetime, /* datetime */ @@ -66,19 +67,18 @@ static const dc_parser_vtable_t reefnet_sensus_parser_vtable = { dc_status_t reefnet_sensus_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int devtime, dc_ticks_t systime) { + reefnet_sensus_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - reefnet_sensus_parser_t *parser = (reefnet_sensus_parser_t *) malloc (sizeof (reefnet_sensus_parser_t)); + parser = (reefnet_sensus_parser_t *) dc_parser_allocate (context, &reefnet_sensus_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &reefnet_sensus_parser_vtable); - // Set the default values. parser->atmospheric = ATM; parser->hydrostatic = 1025.0 * GRAVITY; diff --git a/src/reefnet_sensuspro.c b/src/reefnet_sensuspro.c index 1063166..8e17f1e 100644 --- a/src/reefnet_sensuspro.c +++ b/src/reefnet_sensuspro.c @@ -55,6 +55,7 @@ static dc_status_t reefnet_sensuspro_device_foreach (dc_device_t *abstract, dc_d static dc_status_t reefnet_sensuspro_device_close (dc_device_t *abstract); static const dc_device_vtable_t reefnet_sensuspro_device_vtable = { + sizeof(reefnet_sensuspro_device_t), DC_FAMILY_REEFNET_SENSUSPRO, reefnet_sensuspro_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -75,15 +76,12 @@ reefnet_sensuspro_device_open (dc_device_t **out, dc_context_t *context, const c return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (reefnet_sensuspro_device_t *) malloc (sizeof (reefnet_sensuspro_device_t)); + device = (reefnet_sensuspro_device_t *) dc_device_allocate (context, &reefnet_sensuspro_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &reefnet_sensuspro_device_vtable); - // Set the default values. device->port = NULL; device->timestamp = 0; @@ -124,7 +122,7 @@ reefnet_sensuspro_device_open (dc_device_t **out, dc_context_t *context, const c error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/reefnet_sensuspro_parser.c b/src/reefnet_sensuspro_parser.c index cc9d999..70decf8 100644 --- a/src/reefnet_sensuspro_parser.c +++ b/src/reefnet_sensuspro_parser.c @@ -53,6 +53,7 @@ static dc_status_t reefnet_sensuspro_parser_get_field (dc_parser_t *abstract, dc static dc_status_t reefnet_sensuspro_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t reefnet_sensuspro_parser_vtable = { + sizeof(reefnet_sensuspro_parser_t), DC_FAMILY_REEFNET_SENSUSPRO, reefnet_sensuspro_parser_set_data, /* set_data */ reefnet_sensuspro_parser_get_datetime, /* datetime */ @@ -65,19 +66,18 @@ static const dc_parser_vtable_t reefnet_sensuspro_parser_vtable = { dc_status_t reefnet_sensuspro_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int devtime, dc_ticks_t systime) { + reefnet_sensuspro_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - reefnet_sensuspro_parser_t *parser = (reefnet_sensuspro_parser_t *) malloc (sizeof (reefnet_sensuspro_parser_t)); + parser = (reefnet_sensuspro_parser_t *) dc_parser_allocate (context, &reefnet_sensuspro_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &reefnet_sensuspro_parser_vtable); - // Set the default values. parser->atmospheric = ATM; parser->hydrostatic = 1025.0 * GRAVITY; diff --git a/src/reefnet_sensusultra.c b/src/reefnet_sensusultra.c index d246c14..db070e6 100644 --- a/src/reefnet_sensusultra.c +++ b/src/reefnet_sensusultra.c @@ -64,6 +64,7 @@ static dc_status_t reefnet_sensusultra_device_foreach (dc_device_t *abstract, dc static dc_status_t reefnet_sensusultra_device_close (dc_device_t *abstract); static const dc_device_vtable_t reefnet_sensusultra_device_vtable = { + sizeof(reefnet_sensusultra_device_t), DC_FAMILY_REEFNET_SENSUSULTRA, reefnet_sensusultra_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -84,15 +85,12 @@ reefnet_sensusultra_device_open (dc_device_t **out, dc_context_t *context, const return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (reefnet_sensusultra_device_t *) malloc (sizeof (reefnet_sensusultra_device_t)); + device = (reefnet_sensusultra_device_t *) dc_device_allocate (context, &reefnet_sensusultra_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &reefnet_sensusultra_device_vtable); - // Set the default values. device->port = NULL; device->timestamp = 0; @@ -133,7 +131,7 @@ reefnet_sensusultra_device_open (dc_device_t **out, dc_context_t *context, const error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/reefnet_sensusultra_parser.c b/src/reefnet_sensusultra_parser.c index 339fa0d..d44edfe 100644 --- a/src/reefnet_sensusultra_parser.c +++ b/src/reefnet_sensusultra_parser.c @@ -53,6 +53,7 @@ static dc_status_t reefnet_sensusultra_parser_get_field (dc_parser_t *abstract, static dc_status_t reefnet_sensusultra_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t reefnet_sensusultra_parser_vtable = { + sizeof(reefnet_sensusultra_parser_t), DC_FAMILY_REEFNET_SENSUSULTRA, reefnet_sensusultra_parser_set_data, /* set_data */ reefnet_sensusultra_parser_get_datetime, /* datetime */ @@ -65,19 +66,18 @@ static const dc_parser_vtable_t reefnet_sensusultra_parser_vtable = { dc_status_t reefnet_sensusultra_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int devtime, dc_ticks_t systime) { + reefnet_sensusultra_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - reefnet_sensusultra_parser_t *parser = (reefnet_sensusultra_parser_t *) malloc (sizeof (reefnet_sensusultra_parser_t)); + parser = (reefnet_sensusultra_parser_t *) dc_parser_allocate (context, &reefnet_sensusultra_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &reefnet_sensusultra_parser_vtable); - // Set the default values. parser->atmospheric = ATM; parser->hydrostatic = 1025.0 * GRAVITY; diff --git a/src/shearwater_petrel.c b/src/shearwater_petrel.c index f5e6d76..b791388 100644 --- a/src/shearwater_petrel.c +++ b/src/shearwater_petrel.c @@ -51,6 +51,7 @@ static dc_status_t shearwater_petrel_device_foreach (dc_device_t *abstract, dc_d static dc_status_t shearwater_petrel_device_close (dc_device_t *abstract); static const dc_device_vtable_t shearwater_petrel_device_vtable = { + sizeof(shearwater_petrel_device_t), DC_FAMILY_SHEARWATER_PETREL, shearwater_petrel_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -86,15 +87,12 @@ shearwater_petrel_device_open (dc_device_t **out, dc_context_t *context, const c return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (shearwater_petrel_device_t *) malloc (sizeof (shearwater_petrel_device_t)); + device = (shearwater_petrel_device_t *) dc_device_allocate (context, &shearwater_petrel_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base.base, context, &shearwater_petrel_device_vtable); - // Set the default values. memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -109,7 +107,7 @@ shearwater_petrel_device_open (dc_device_t **out, dc_context_t *context, const c return DC_STATUS_SUCCESS; error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/shearwater_predator.c b/src/shearwater_predator.c index f5cfbc6..7975b8f 100644 --- a/src/shearwater_predator.c +++ b/src/shearwater_predator.c @@ -52,6 +52,7 @@ static dc_status_t shearwater_predator_device_foreach (dc_device_t *abstract, dc static dc_status_t shearwater_predator_device_close (dc_device_t *abstract); static const dc_device_vtable_t shearwater_predator_device_vtable = { + sizeof(shearwater_predator_device_t), DC_FAMILY_SHEARWATER_PREDATOR, shearwater_predator_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -72,15 +73,12 @@ shearwater_predator_device_open (dc_device_t **out, dc_context_t *context, const return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (shearwater_predator_device_t *) malloc (sizeof (shearwater_predator_device_t)); + device = (shearwater_predator_device_t *) dc_device_allocate (context, &shearwater_predator_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base.base, context, &shearwater_predator_device_vtable); - // Set the default values. memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -95,7 +93,7 @@ shearwater_predator_device_open (dc_device_t **out, dc_context_t *context, const return DC_STATUS_SUCCESS; error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/shearwater_predator_parser.c b/src/shearwater_predator_parser.c index cacdcca..f1a5c31 100644 --- a/src/shearwater_predator_parser.c +++ b/src/shearwater_predator_parser.c @@ -69,6 +69,7 @@ static dc_status_t shearwater_predator_parser_get_field (dc_parser_t *abstract, static dc_status_t shearwater_predator_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t shearwater_predator_parser_vtable = { + sizeof(shearwater_predator_parser_t), DC_FAMILY_SHEARWATER_PREDATOR, shearwater_predator_parser_set_data, /* set_data */ shearwater_predator_parser_get_datetime, /* datetime */ @@ -78,6 +79,7 @@ static const dc_parser_vtable_t shearwater_predator_parser_vtable = { }; static const dc_parser_vtable_t shearwater_petrel_parser_vtable = { + sizeof(shearwater_predator_parser_t), DC_FAMILY_SHEARWATER_PETREL, shearwater_predator_parser_set_data, /* set_data */ shearwater_predator_parser_get_datetime, /* datetime */ @@ -104,27 +106,31 @@ shearwater_predator_find_gasmix (shearwater_predator_parser_t *parser, unsigned dc_status_t shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int petrel) { + shearwater_predator_parser_t *parser = NULL; + const dc_parser_vtable_t *vtable = NULL; + unsigned int samplesize = 0; + if (out == NULL) return DC_STATUS_INVALIDARGS; + if (petrel) { + vtable = &shearwater_petrel_parser_vtable; + samplesize = SZ_SAMPLE_PETREL; + } else { + vtable = &shearwater_predator_parser_vtable; + samplesize = SZ_SAMPLE_PREDATOR; + } + // Allocate memory. - shearwater_predator_parser_t *parser = (shearwater_predator_parser_t *) malloc (sizeof (shearwater_predator_parser_t)); + parser = (shearwater_predator_parser_t *) dc_parser_allocate (context, vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser->petrel = petrel; - if (petrel) { - parser_init (&parser->base, context, &shearwater_petrel_parser_vtable); - parser->samplesize = SZ_SAMPLE_PETREL; - } else { - parser_init (&parser->base, context, &shearwater_predator_parser_vtable); - parser->samplesize = SZ_SAMPLE_PREDATOR; - } - // Set the default values. + parser->petrel = petrel; + parser->samplesize = samplesize; parser->cached = 0; parser->headersize = 0; parser->footersize = 0; diff --git a/src/suunto_common.c b/src/suunto_common.c index 44c5299..9988b86 100644 --- a/src/suunto_common.c +++ b/src/suunto_common.c @@ -31,13 +31,10 @@ #define RB_PROFILE_PEEK(a,l) ringbuffer_decrement (a, l->peek, l->rb_profile_begin, l->rb_profile_end) void -suunto_common_device_init (suunto_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable) +suunto_common_device_init (suunto_common_device_t *device) { assert (device != NULL); - // Initialize the base class. - device_init (&device->base, context, vtable); - // Set the default values. memset (device->fingerprint, 0, sizeof (device->fingerprint)); } diff --git a/src/suunto_common.h b/src/suunto_common.h index 151fe45..49fb29f 100644 --- a/src/suunto_common.h +++ b/src/suunto_common.h @@ -46,7 +46,7 @@ typedef struct suunto_common_layout_t { } suunto_common_layout_t; void -suunto_common_device_init (suunto_common_device_t *device, dc_context_t *context, const dc_device_vtable_t *vtable); +suunto_common_device_init (suunto_common_device_t *device); dc_status_t suunto_common_device_set_fingerprint (dc_device_t *device, const unsigned char data[], unsigned int size); diff --git a/src/suunto_common2.c b/src/suunto_common2.c index 2149612..2abe386 100644 --- a/src/suunto_common2.c +++ b/src/suunto_common2.c @@ -40,13 +40,10 @@ #define VTABLE(abstract) ((suunto_common2_device_vtable_t *) abstract->vtable) void -suunto_common2_device_init (suunto_common2_device_t *device, dc_context_t *context, const suunto_common2_device_vtable_t *vtable) +suunto_common2_device_init (suunto_common2_device_t *device) { assert (device != NULL); - // Initialize the base class. - device_init (&device->base, context, &vtable->base); - // Set the default values. device->layout = NULL; memset (device->version, 0, sizeof (device->version)); diff --git a/src/suunto_common2.h b/src/suunto_common2.h index bbcf72b..5eff8d2 100644 --- a/src/suunto_common2.h +++ b/src/suunto_common2.h @@ -53,7 +53,7 @@ typedef struct suunto_common2_device_vtable_t { } suunto_common2_device_vtable_t; void -suunto_common2_device_init (suunto_common2_device_t *device, dc_context_t *context, const suunto_common2_device_vtable_t *vtable); +suunto_common2_device_init (suunto_common2_device_t *device); dc_status_t suunto_common2_device_set_fingerprint (dc_device_t *device, const unsigned char data[], unsigned int size); diff --git a/src/suunto_d9.c b/src/suunto_d9.c index ce3ff89..0d51540 100644 --- a/src/suunto_d9.c +++ b/src/suunto_d9.c @@ -55,6 +55,7 @@ static dc_status_t suunto_d9_device_close (dc_device_t *abstract); static const suunto_common2_device_vtable_t suunto_d9_device_vtable = { { + sizeof(suunto_d9_device_t), DC_FAMILY_SUUNTO_D9, suunto_common2_device_set_fingerprint, /* set_fingerprint */ suunto_common2_device_read, /* read */ @@ -136,14 +137,14 @@ suunto_d9_device_open (dc_device_t **out, dc_context_t *context, const char *nam return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (suunto_d9_device_t *) malloc (sizeof (suunto_d9_device_t)); + device = (suunto_d9_device_t *) dc_device_allocate (context, &suunto_d9_device_vtable.base); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - suunto_common2_device_init (&device->base, context, &suunto_d9_device_vtable); + suunto_common2_device_init (&device->base); // Set the default values. device->port = NULL; @@ -207,7 +208,7 @@ suunto_d9_device_open (dc_device_t **out, dc_context_t *context, const char *nam error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/suunto_d9_parser.c b/src/suunto_d9_parser.c index adda93b..4b312d4 100644 --- a/src/suunto_d9_parser.c +++ b/src/suunto_d9_parser.c @@ -85,6 +85,7 @@ static dc_status_t suunto_d9_parser_get_field (dc_parser_t *abstract, dc_field_t static dc_status_t suunto_d9_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t suunto_d9_parser_vtable = { + sizeof(suunto_d9_parser_t), DC_FAMILY_SUUNTO_D9, suunto_d9_parser_set_data, /* set_data */ suunto_d9_parser_get_datetime, /* datetime */ @@ -202,19 +203,18 @@ suunto_d9_parser_cache (suunto_d9_parser_t *parser) dc_status_t suunto_d9_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model) { + suunto_d9_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - suunto_d9_parser_t *parser = (suunto_d9_parser_t *) malloc (sizeof (suunto_d9_parser_t)); + parser = (suunto_d9_parser_t *) dc_parser_allocate (context, &suunto_d9_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &suunto_d9_parser_vtable); - // Set the default values. parser->model = model; parser->cached = 0; diff --git a/src/suunto_eon.c b/src/suunto_eon.c index 306dac5..6e8375c 100644 --- a/src/suunto_eon.c +++ b/src/suunto_eon.c @@ -50,6 +50,7 @@ static dc_status_t suunto_eon_device_foreach (dc_device_t *abstract, dc_dive_cal static dc_status_t suunto_eon_device_close (dc_device_t *abstract); static const dc_device_vtable_t suunto_eon_device_vtable = { + sizeof(suunto_eon_device_t), DC_FAMILY_SUUNTO_EON, suunto_common_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -78,14 +79,14 @@ suunto_eon_device_open (dc_device_t **out, dc_context_t *context, const char *na return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (suunto_eon_device_t *) malloc (sizeof (suunto_eon_device_t)); + device = (suunto_eon_device_t *) dc_device_allocate (context, &suunto_eon_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - suunto_common_device_init (&device->base, context, &suunto_eon_device_vtable); + suunto_common_device_init (&device->base); // Set the default values. device->port = NULL; @@ -127,7 +128,7 @@ suunto_eon_device_open (dc_device_t **out, dc_context_t *context, const char *na error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/suunto_eon_parser.c b/src/suunto_eon_parser.c index be38d7f..70fa74f 100644 --- a/src/suunto_eon_parser.c +++ b/src/suunto_eon_parser.c @@ -49,6 +49,7 @@ static dc_status_t suunto_eon_parser_get_field (dc_parser_t *abstract, dc_field_ static dc_status_t suunto_eon_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t suunto_eon_parser_vtable = { + sizeof(suunto_eon_parser_t), DC_FAMILY_SUUNTO_EON, suunto_eon_parser_set_data, /* set_data */ suunto_eon_parser_get_datetime, /* datetime */ @@ -110,19 +111,18 @@ suunto_eon_parser_cache (suunto_eon_parser_t *parser) dc_status_t suunto_eon_parser_create (dc_parser_t **out, dc_context_t *context, int spyder) { + suunto_eon_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - suunto_eon_parser_t *parser = (suunto_eon_parser_t *) malloc (sizeof (suunto_eon_parser_t)); + parser = (suunto_eon_parser_t *) dc_parser_allocate (context, &suunto_eon_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &suunto_eon_parser_vtable); - // Set the default values. parser->spyder = spyder; parser->cached = 0; diff --git a/src/suunto_eonsteel.c b/src/suunto_eonsteel.c index 03b6f99..ec7cfe3 100644 --- a/src/suunto_eonsteel.c +++ b/src/suunto_eonsteel.c @@ -85,6 +85,7 @@ static dc_status_t suunto_eonsteel_device_foreach(dc_device_t *abstract, dc_dive static dc_status_t suunto_eonsteel_device_close(dc_device_t *abstract); static const dc_device_vtable_t suunto_eonsteel_device_vtable = { + sizeof(suunto_eonsteel_device_t), DC_FAMILY_SUUNTO_EONSTEEL, NULL, /* set_fingerprint */ NULL, /* read */ @@ -557,12 +558,12 @@ dc_status_t suunto_eonsteel_device_open(dc_device_t **out, dc_context_t *context, const char *name, unsigned int model) { dc_status_t status = DC_STATUS_SUCCESS; - suunto_eonsteel_device_t *eon; + suunto_eonsteel_device_t *eon = NULL; if (out == NULL) return DC_STATUS_INVALIDARGS; - eon = (suunto_eonsteel_device_t *) calloc(1, sizeof(suunto_eonsteel_device_t)); + eon = (suunto_eonsteel_device_t *) dc_device_allocate(context, &suunto_eonsteel_device_vtable); if (!eon) return DC_STATUS_NOMEMORY; @@ -570,9 +571,6 @@ suunto_eonsteel_device_open(dc_device_t **out, dc_context_t *context, const char eon->magic = INIT_MAGIC; eon->seq = INIT_SEQ; - // Set up the libdivecomputer interfaces - device_init(&eon->base, context, &suunto_eonsteel_device_vtable); - if (libusb_init(&eon->ctx)) { ERROR(context, "libusb_init() failed"); status = DC_STATUS_IO; diff --git a/src/suunto_eonsteel_parser.c b/src/suunto_eonsteel_parser.c index e638bde..19fbf99 100644 --- a/src/suunto_eonsteel_parser.c +++ b/src/suunto_eonsteel_parser.c @@ -1196,6 +1196,7 @@ suunto_eonsteel_parser_destroy(dc_parser_t *parser) } static const dc_parser_vtable_t suunto_eonsteel_parser_vtable = { + sizeof(suunto_eonsteel_parser_t), DC_FAMILY_SUUNTO_EONSTEEL, suunto_eonsteel_parser_set_data, /* set_data */ suunto_eonsteel_parser_get_datetime, /* datetime */ @@ -1207,18 +1208,21 @@ static const dc_parser_vtable_t suunto_eonsteel_parser_vtable = { dc_status_t suunto_eonsteel_parser_create(dc_parser_t **out, dc_context_t *context, unsigned int model) { - suunto_eonsteel_parser_t *eon; + suunto_eonsteel_parser_t *parser = NULL; if (out == NULL) return DC_STATUS_INVALIDARGS; - eon = (suunto_eonsteel_parser_t *) calloc(1, sizeof(*eon)); - if (!eon) + parser = (suunto_eonsteel_parser_t *) dc_parser_allocate (context, &suunto_eonsteel_parser_vtable); + if (parser == NULL) { + ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; + } - parser_init(&eon->base, context, &suunto_eonsteel_parser_vtable); + memset(&parser->type_desc, 0, sizeof(parser->type_desc)); + memset(&parser->cache, 0, sizeof(parser->cache)); - *out = (dc_parser_t *) eon; + *out = (dc_parser_t *) parser; return DC_STATUS_SUCCESS; } diff --git a/src/suunto_solution.c b/src/suunto_solution.c index 3ff1f60..d151352 100644 --- a/src/suunto_solution.c +++ b/src/suunto_solution.c @@ -52,6 +52,7 @@ static dc_status_t suunto_solution_device_foreach (dc_device_t *abstract, dc_div static dc_status_t suunto_solution_device_close (dc_device_t *abstract); static const dc_device_vtable_t suunto_solution_device_vtable = { + sizeof(suunto_solution_device_t), DC_FAMILY_SUUNTO_SOLUTION, NULL, /* set_fingerprint */ NULL, /* read */ @@ -72,15 +73,12 @@ suunto_solution_device_open (dc_device_t **out, dc_context_t *context, const cha return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (suunto_solution_device_t *) malloc (sizeof (suunto_solution_device_t)); + device = (suunto_solution_device_t *) dc_device_allocate (context, &suunto_solution_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &suunto_solution_device_vtable); - // Set the default values. device->port = NULL; @@ -121,7 +119,7 @@ suunto_solution_device_open (dc_device_t **out, dc_context_t *context, const cha error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/suunto_solution_parser.c b/src/suunto_solution_parser.c index 8a6ad62..8372457 100644 --- a/src/suunto_solution_parser.c +++ b/src/suunto_solution_parser.c @@ -44,6 +44,7 @@ static dc_status_t suunto_solution_parser_get_field (dc_parser_t *abstract, dc_f static dc_status_t suunto_solution_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t suunto_solution_parser_vtable = { + sizeof(suunto_solution_parser_t), DC_FAMILY_SUUNTO_SOLUTION, suunto_solution_parser_set_data, /* set_data */ NULL, /* datetime */ @@ -56,19 +57,18 @@ static const dc_parser_vtable_t suunto_solution_parser_vtable = { dc_status_t suunto_solution_parser_create (dc_parser_t **out, dc_context_t *context) { + suunto_solution_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - suunto_solution_parser_t *parser = (suunto_solution_parser_t *) malloc (sizeof (suunto_solution_parser_t)); + parser = (suunto_solution_parser_t *) dc_parser_allocate (context, &suunto_solution_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &suunto_solution_parser_vtable); - // Set the default values. parser->cached = 0; parser->divetime = 0; diff --git a/src/suunto_vyper.c b/src/suunto_vyper.c index 701fbeb..8ec502f 100644 --- a/src/suunto_vyper.c +++ b/src/suunto_vyper.c @@ -62,6 +62,7 @@ static dc_status_t suunto_vyper_device_foreach (dc_device_t *abstract, dc_dive_c static dc_status_t suunto_vyper_device_close (dc_device_t *abstract); static const dc_device_vtable_t suunto_vyper_device_vtable = { + sizeof(suunto_vyper_device_t), DC_FAMILY_SUUNTO_VYPER, suunto_common_device_set_fingerprint, /* set_fingerprint */ suunto_vyper_device_read, /* read */ @@ -98,14 +99,14 @@ suunto_vyper_device_open (dc_device_t **out, dc_context_t *context, const char * return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (suunto_vyper_device_t *) malloc (sizeof (suunto_vyper_device_t)); + device = (suunto_vyper_device_t *) dc_device_allocate (context, &suunto_vyper_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - suunto_common_device_init (&device->base, context, &suunto_vyper_device_vtable); + suunto_common_device_init (&device->base); // Set the default values. device->port = NULL; @@ -153,7 +154,7 @@ suunto_vyper_device_open (dc_device_t **out, dc_context_t *context, const char * error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/suunto_vyper2.c b/src/suunto_vyper2.c index e701164..a0b07a4 100644 --- a/src/suunto_vyper2.c +++ b/src/suunto_vyper2.c @@ -49,6 +49,7 @@ static dc_status_t suunto_vyper2_device_close (dc_device_t *abstract); static const suunto_common2_device_vtable_t suunto_vyper2_device_vtable = { { + sizeof(suunto_vyper2_device_t), DC_FAMILY_SUUNTO_VYPER2, suunto_common2_device_set_fingerprint, /* set_fingerprint */ suunto_common2_device_read, /* read */ @@ -87,14 +88,14 @@ suunto_vyper2_device_open (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (suunto_vyper2_device_t *) malloc (sizeof (suunto_vyper2_device_t)); + device = (suunto_vyper2_device_t *) dc_device_allocate (context, &suunto_vyper2_device_vtable.base); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } // Initialize the base class. - suunto_common2_device_init (&device->base, context, &suunto_vyper2_device_vtable); + suunto_common2_device_init (&device->base); // Set the default values. device->port = NULL; @@ -159,7 +160,7 @@ suunto_vyper2_device_open (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/suunto_vyper_parser.c b/src/suunto_vyper_parser.c index 4628cb1..7eee580 100644 --- a/src/suunto_vyper_parser.c +++ b/src/suunto_vyper_parser.c @@ -50,6 +50,7 @@ static dc_status_t suunto_vyper_parser_get_field (dc_parser_t *abstract, dc_fiel static dc_status_t suunto_vyper_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t suunto_vyper_parser_vtable = { + sizeof(suunto_vyper_parser_t), DC_FAMILY_SUUNTO_VYPER, suunto_vyper_parser_set_data, /* set_data */ suunto_vyper_parser_get_datetime, /* datetime */ @@ -160,19 +161,18 @@ suunto_vyper_parser_cache (suunto_vyper_parser_t *parser) dc_status_t suunto_vyper_parser_create (dc_parser_t **out, dc_context_t *context) { + suunto_vyper_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - suunto_vyper_parser_t *parser = (suunto_vyper_parser_t *) malloc (sizeof (suunto_vyper_parser_t)); + parser = (suunto_vyper_parser_t *) dc_parser_allocate (context, &suunto_vyper_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &suunto_vyper_parser_vtable); - // Set the default values. parser->cached = 0; parser->divetime = 0; diff --git a/src/uwatec_aladin.c b/src/uwatec_aladin.c index 7cd7dff..47c0ee2 100644 --- a/src/uwatec_aladin.c +++ b/src/uwatec_aladin.c @@ -61,6 +61,7 @@ static dc_status_t uwatec_aladin_device_foreach (dc_device_t *abstract, dc_dive_ static dc_status_t uwatec_aladin_device_close (dc_device_t *abstract); static const dc_device_vtable_t uwatec_aladin_device_vtable = { + sizeof(uwatec_aladin_device_t), DC_FAMILY_UWATEC_ALADIN, uwatec_aladin_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -81,15 +82,12 @@ uwatec_aladin_device_open (dc_device_t **out, dc_context_t *context, const char return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (uwatec_aladin_device_t *) malloc (sizeof (uwatec_aladin_device_t)); + device = (uwatec_aladin_device_t *) dc_device_allocate (context, &uwatec_aladin_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &uwatec_aladin_device_vtable); - // Set the default values. device->port = NULL; device->timestamp = 0; @@ -134,7 +132,7 @@ uwatec_aladin_device_open (dc_device_t **out, dc_context_t *context, const char error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/uwatec_memomouse.c b/src/uwatec_memomouse.c index 29b2c69..ba1153a 100644 --- a/src/uwatec_memomouse.c +++ b/src/uwatec_memomouse.c @@ -57,6 +57,7 @@ static dc_status_t uwatec_memomouse_device_foreach (dc_device_t *abstract, dc_di static dc_status_t uwatec_memomouse_device_close (dc_device_t *abstract); static const dc_device_vtable_t uwatec_memomouse_device_vtable = { + sizeof(uwatec_memomouse_device_t), DC_FAMILY_UWATEC_MEMOMOUSE, uwatec_memomouse_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -77,15 +78,12 @@ uwatec_memomouse_device_open (dc_device_t **out, dc_context_t *context, const ch return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (uwatec_memomouse_device_t *) malloc (sizeof (uwatec_memomouse_device_t)); + device = (uwatec_memomouse_device_t *) dc_device_allocate (context, &uwatec_memomouse_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &uwatec_memomouse_device_vtable); - // Set the default values. device->port = NULL; device->timestamp = 0; @@ -133,7 +131,7 @@ uwatec_memomouse_device_open (dc_device_t **out, dc_context_t *context, const ch error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/uwatec_memomouse_parser.c b/src/uwatec_memomouse_parser.c index 98fc25d..ce52200 100644 --- a/src/uwatec_memomouse_parser.c +++ b/src/uwatec_memomouse_parser.c @@ -44,6 +44,7 @@ static dc_status_t uwatec_memomouse_parser_get_field (dc_parser_t *abstract, dc_ static dc_status_t uwatec_memomouse_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t uwatec_memomouse_parser_vtable = { + sizeof(uwatec_memomouse_parser_t), DC_FAMILY_UWATEC_MEMOMOUSE, uwatec_memomouse_parser_set_data, /* set_data */ uwatec_memomouse_parser_get_datetime, /* datetime */ @@ -56,19 +57,18 @@ static const dc_parser_vtable_t uwatec_memomouse_parser_vtable = { dc_status_t uwatec_memomouse_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int devtime, dc_ticks_t systime) { + uwatec_memomouse_parser_t *parser = NULL; + if (out == NULL) return DC_STATUS_INVALIDARGS; // Allocate memory. - uwatec_memomouse_parser_t *parser = (uwatec_memomouse_parser_t *) malloc (sizeof (uwatec_memomouse_parser_t)); + parser = (uwatec_memomouse_parser_t *) dc_parser_allocate (context, &uwatec_memomouse_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &uwatec_memomouse_parser_vtable); - // Set the default values. parser->devtime = devtime; parser->systime = systime; diff --git a/src/uwatec_meridian.c b/src/uwatec_meridian.c index dda19bd..e8de867 100644 --- a/src/uwatec_meridian.c +++ b/src/uwatec_meridian.c @@ -55,6 +55,7 @@ static dc_status_t uwatec_meridian_device_foreach (dc_device_t *abstract, dc_div static dc_status_t uwatec_meridian_device_close (dc_device_t *abstract); static const dc_device_vtable_t uwatec_meridian_device_vtable = { + sizeof(uwatec_meridian_device_t), DC_FAMILY_UWATEC_MERIDIAN, uwatec_meridian_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -193,15 +194,12 @@ uwatec_meridian_device_open (dc_device_t **out, dc_context_t *context, const cha return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (uwatec_meridian_device_t *) malloc (sizeof (uwatec_meridian_device_t)); + device = (uwatec_meridian_device_t *) dc_device_allocate (context, &uwatec_meridian_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &uwatec_meridian_device_vtable); - // Set the default values. device->port = NULL; device->timestamp = 0; @@ -244,7 +242,7 @@ uwatec_meridian_device_open (dc_device_t **out, dc_context_t *context, const cha error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/uwatec_smart.c b/src/uwatec_smart.c index 2d45294..065943f 100644 --- a/src/uwatec_smart.c +++ b/src/uwatec_smart.c @@ -51,6 +51,7 @@ static dc_status_t uwatec_smart_device_foreach (dc_device_t *abstract, dc_dive_c static dc_status_t uwatec_smart_device_close (dc_device_t *abstract); static const dc_device_vtable_t uwatec_smart_device_vtable = { + sizeof(uwatec_smart_device_t), DC_FAMILY_UWATEC_SMART, uwatec_smart_device_set_fingerprint, /* set_fingerprint */ NULL, /* read */ @@ -152,15 +153,12 @@ uwatec_smart_device_open (dc_device_t **out, dc_context_t *context) return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (uwatec_smart_device_t *) malloc (sizeof (uwatec_smart_device_t)); + device = (uwatec_smart_device_t *) dc_device_allocate (context, &uwatec_smart_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &uwatec_smart_device_vtable); - // Set the default values. device->socket = NULL; device->address = 0; @@ -208,7 +206,7 @@ uwatec_smart_device_open (dc_device_t **out, dc_context_t *context) error_close: irda_socket_close (device->socket); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; } diff --git a/src/uwatec_smart_parser.c b/src/uwatec_smart_parser.c index 1fe57d7..eaa72d6 100644 --- a/src/uwatec_smart_parser.c +++ b/src/uwatec_smart_parser.c @@ -152,6 +152,7 @@ static dc_status_t uwatec_smart_parser_get_field (dc_parser_t *abstract, dc_fiel static dc_status_t uwatec_smart_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata); static const dc_parser_vtable_t uwatec_smart_parser_vtable = { + sizeof(uwatec_smart_parser_t), DC_FAMILY_UWATEC_SMART, uwatec_smart_parser_set_data, /* set_data */ uwatec_smart_parser_get_datetime, /* datetime */ @@ -518,15 +519,12 @@ uwatec_smart_parser_create (dc_parser_t **out, dc_context_t *context, unsigned i return DC_STATUS_INVALIDARGS; // Allocate memory. - parser = (uwatec_smart_parser_t *) malloc (sizeof (uwatec_smart_parser_t)); + parser = (uwatec_smart_parser_t *) dc_parser_allocate (context, &uwatec_smart_parser_vtable); if (parser == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - parser_init (&parser->base, context, &uwatec_smart_parser_vtable); - // Set the default values. parser->model = model; parser->devtime = devtime; @@ -620,7 +618,7 @@ uwatec_smart_parser_create (dc_parser_t **out, dc_context_t *context, unsigned i return DC_STATUS_SUCCESS; error_free: - free (parser); + dc_parser_deallocate ((dc_parser_t *) parser); return status; } diff --git a/src/zeagle_n2ition3.c b/src/zeagle_n2ition3.c index ff7f8c2..ae76696 100644 --- a/src/zeagle_n2ition3.c +++ b/src/zeagle_n2ition3.c @@ -62,6 +62,7 @@ static dc_status_t zeagle_n2ition3_device_foreach (dc_device_t *abstract, dc_div static dc_status_t zeagle_n2ition3_device_close (dc_device_t *abstract); static const dc_device_vtable_t zeagle_n2ition3_device_vtable = { + sizeof(zeagle_n2ition3_device_t), DC_FAMILY_ZEAGLE_N2ITION3, zeagle_n2ition3_device_set_fingerprint, /* set_fingerprint */ zeagle_n2ition3_device_read, /* read */ @@ -144,15 +145,12 @@ zeagle_n2ition3_device_open (dc_device_t **out, dc_context_t *context, const cha return DC_STATUS_INVALIDARGS; // Allocate memory. - device = (zeagle_n2ition3_device_t *) malloc (sizeof (zeagle_n2ition3_device_t)); + device = (zeagle_n2ition3_device_t *) dc_device_allocate (context, &zeagle_n2ition3_device_vtable); if (device == NULL) { ERROR (context, "Failed to allocate memory."); return DC_STATUS_NOMEMORY; } - // Initialize the base class. - device_init (&device->base, context, &zeagle_n2ition3_device_vtable); - // Set the default values. device->port = NULL; memset (device->fingerprint, 0, sizeof (device->fingerprint)); @@ -193,7 +191,7 @@ zeagle_n2ition3_device_open (dc_device_t **out, dc_context_t *context, const cha error_close: serial_close (device->port); error_free: - free (device); + dc_device_deallocate ((dc_device_t *) device); return status; }