Subversion Repositories public

Compare Revisions

Ignore whitespace Rev 313 → Rev 314

/sportwatcher/trunk/libgarmin/datatype.c
15,6 → 15,7
if (!d)
return NULL;
 
memset(d, 0, sizeof(garmin_data));
d->type = type;
 
#define CASE_DATA(x) \
93,6 → 94,7
if ((l = calloc(1,sizeof(garmin_list))) == NULL)
return NULL;
 
memset(l, 0, sizeof(garmin_list));
l->id = ++gListId;
 
return l;
102,70 → 104,74
garmin_list *
garmin_list_append ( garmin_list * list, garmin_data * data )
{
garmin_list * l = list;
garmin_list_node * n;
garmin_list * l = list;
garmin_list_node * n;
 
if ( data != NULL )
{
if ( l == NULL )
{
if ((l = garmin_alloc_list()) == NULL)
return NULL;
}
if ( data != NULL )
{
if ( l == NULL )
{
if ( ( l = garmin_alloc_list() ) == NULL )
return NULL;
}
 
if ((n = malloc(sizeof(garmin_list_node))) == NULL)
return NULL;
if ( ( n = malloc ( sizeof ( garmin_list_node ) ) ) == NULL )
return NULL;
 
n->data = data;
n->next = NULL;
memset(n, 0, sizeof(garmin_list_node));
n->data = data;
n->next = NULL;
 
if ( l->head == NULL )
l->head = n;
if ( l->head == NULL )
l->head = n;
 
if ( l->tail != NULL )
l->tail->next = n;
if ( l->tail != NULL )
l->tail->next = n;
 
l->tail = n;
l->elements++;
}
l->tail = n;
l->elements++;
}
 
return l;
return l;
}
 
 
garmin_data *
garmin_list_data ( garmin_data * data, uint32 which )
garmin_data *garmin_list_data (garmin_data *data, uint32 which)
{
garmin_data * ret = NULL;
garmin_list * list;
garmin_list_node * n;
unsigned int i;
garmin_data * ret = NULL;
garmin_list * list;
garmin_list_node * n;
unsigned int i;
 
if ( data != NULL &&
data->type == data_Dlist &&
(list = data->data) != NULL ) {
for ( i = 0, n = list->head; i < which && n != NULL; i++, n = n->next );
if ( n != NULL ) ret = n->data;
}
if (data != NULL && data->type == data_Dlist && (list = data->data) != NULL)
{
for ( i = 0, n = list->head; i < which && n != NULL; i++, n = n->next );
 
return ret;
if ( n != NULL )
ret = n->data;
}
 
return ret;
}
 
 
void
garmin_free_list ( garmin_list * l )
garmin_free_list (garmin_list *l)
{
garmin_list_node * n;
garmin_list_node * x;
garmin_list_node *n;
garmin_list_node *x;
 
if ( l != NULL ) {
for ( n = l->head; n != NULL; n = x ) {
x = n->next;
garmin_free_data(n->data);
free(n);
if ( l != NULL )
{
for ( n = l->head; n != NULL; n = x )
{
x = n->next;
garmin_free_data (n->data);
free (n);
}
 
free (l);
}
free(l);
}
}
 
 
172,16 → 178,18
void
garmin_free_list_only ( garmin_list * l )
{
garmin_list_node * n;
garmin_list_node * x;
garmin_list_node * n;
garmin_list_node * x;
 
if ( l != NULL ) {
for ( n = l->head; n != NULL; n = x ) {
x = n->next;
free(n);
if ( l != NULL )
{
for ( n = l->head; n != NULL; n = x )
{
x = n->next;
free ( n );
}
free ( l );
}
free(l);
}
}
 
 
191,95 → 199,101
void
garmin_free_data ( garmin_data * d )
{
D105 * d105;
D106 * d106;
D108 * d108;
D109 * d109;
D110 * d110;
D202 * d202;
D210 * d210;
D310 * d310;
D312 * d312;
D650 * d650;
D105 * d105;
D106 * d106;
D108 * d108;
D109 * d109;
D110 * d110;
D202 * d202;
D210 * d210;
D310 * d310;
D312 * d312;
D650 * d650;
 
if ( d != NULL ) {
if ( d->data != NULL ) {
if ( d->type == data_Dlist ) {
garmin_free_list((garmin_list *)d->data);
} else {
switch ( d->type ) {
case data_D105:
d105 = d->data;
TRYFREE(d105->wpt_ident);
break;
case data_D106:
d106 = d->data;
TRYFREE(d106->wpt_ident);
TRYFREE(d106->lnk_ident);
break;
case data_D108:
d108 = d->data;
TRYFREE(d108->ident);
TRYFREE(d108->comment);
TRYFREE(d108->facility);
TRYFREE(d108->city);
TRYFREE(d108->addr);
TRYFREE(d108->cross_road);
break;
case data_D109:
d109 = d->data;
TRYFREE(d109->ident);
TRYFREE(d109->comment);
TRYFREE(d109->facility);
TRYFREE(d109->city);
TRYFREE(d109->addr);
TRYFREE(d109->cross_road);
break;
case data_D110:
d110 = d->data;
TRYFREE(d110->ident);
TRYFREE(d110->comment);
TRYFREE(d110->facility);
TRYFREE(d110->city);
TRYFREE(d110->addr);
TRYFREE(d110->cross_road);
break;
case data_D202:
d202 = d->data;
TRYFREE(d202->rte_ident);
break;
case data_D210:
d210 = d->data;
TRYFREE(d210->ident);
break;
case data_D310:
d310 = d->data;
TRYFREE(d310->trk_ident);
break;
case data_D312:
d312 = d->data;
TRYFREE(d312->trk_ident);
break;
case data_D650:
d650 = d->data;
TRYFREE(d650->departure_name);
TRYFREE(d650->departure_ident);
TRYFREE(d650->arrival_name);
TRYFREE(d650->arrival_ident);
TRYFREE(d650->ac_id);
break;
default:
break;
}
free(d->data);
}
if ( d != NULL )
{
if ( d->data != NULL )
{
if ( d->type == data_Dlist )
{
garmin_free_list ( ( garmin_list * ) d->data );
}
else
{
switch ( d->type )
{
case data_D105:
d105 = d->data;
TRYFREE ( d105->wpt_ident );
break;
case data_D106:
d106 = d->data;
TRYFREE ( d106->wpt_ident );
TRYFREE ( d106->lnk_ident );
break;
case data_D108:
d108 = d->data;
TRYFREE ( d108->ident );
TRYFREE ( d108->comment );
TRYFREE ( d108->facility );
TRYFREE ( d108->city );
TRYFREE ( d108->addr );
TRYFREE ( d108->cross_road );
break;
case data_D109:
d109 = d->data;
TRYFREE ( d109->ident );
TRYFREE ( d109->comment );
TRYFREE ( d109->facility );
TRYFREE ( d109->city );
TRYFREE ( d109->addr );
TRYFREE ( d109->cross_road );
break;
case data_D110:
d110 = d->data;
TRYFREE ( d110->ident );
TRYFREE ( d110->comment );
TRYFREE ( d110->facility );
TRYFREE ( d110->city );
TRYFREE ( d110->addr );
TRYFREE ( d110->cross_road );
break;
case data_D202:
d202 = d->data;
TRYFREE ( d202->rte_ident );
break;
case data_D210:
d210 = d->data;
TRYFREE ( d210->ident );
break;
case data_D310:
d310 = d->data;
TRYFREE ( d310->trk_ident );
break;
case data_D312:
d312 = d->data;
TRYFREE ( d312->trk_ident );
break;
case data_D650:
d650 = d->data;
TRYFREE ( d650->departure_name );
TRYFREE ( d650->departure_ident );
TRYFREE ( d650->arrival_name );
TRYFREE ( d650->arrival_ident );
TRYFREE ( d650->ac_id );
break;
default:
break;
}
free ( d->data );
}
}
free ( d );
}
free(d);
}
}
 
 
/*
/*
Returns the number of bytes needed in order to serialize the data. Note
that this is an upper bound! Some of the Garmin data structures do not
align to word boundaries. Their memory representation will take up more
294,11 → 308,11
uint32 bytes = 0;
char hv0[256];
 
/*
/*
The number of bytes needed in order to serialize a Garmin data structure
is almost equal to the size of its data structure - but not quite. If
we have variable length strings, we need to add their string lengths
(including space for the terminating '\0') and subtract the size of the
(including space for the terminating '\0') and subtract the size of the
char * placeholders. We also need 4 bytes for the data type, and 4
additional bytes in which we store the number of bytes that we should
seek forward in order to skip this record. This allows us to handle