WebSVN – public – Diff – /sportwatcher/trunk/libgarmin/datatype.c

   garmin_data * d = malloc(sizeof(garmin_data));
   if (!d)
      return NULL;
+  memset(d, 0, sizeof(garmin_data));
   d->type = type;
 #define CASE_DATA(x) \
   case data_D##x: d->data = calloc(1,sizeof(D##x)); break
   garmin_list * l;
   if ((l = calloc(1,sizeof(garmin_list))) == NULL)
      return NULL;
+  memset(l, 0, sizeof(garmin_list));
   l->id = ++gListId;
   return l;
+}
 garmin_list *
 garmin_list_append ( garmin_list * list, garmin_data * data )
+{
-garmin_list *      l = list;
+    garmin_list *      l = list;
-garmin_list_node * n;
+    garmin_list_node * n;
-	if ( data != NULL )
+    if ( data != NULL )
-	{
+    {
-	   if ( l == NULL )
+        if ( l == NULL )
-	   {
+        {
-	      if ((l = garmin_alloc_list()) == NULL)
+            if ( ( l = garmin_alloc_list() ) == NULL )
-		 return NULL;
+                return NULL;
-	   }
+        }
-	   if ((n = malloc(sizeof(garmin_list_node))) == NULL)
+        if ( ( n = malloc ( sizeof ( garmin_list_node ) ) ) == NULL )
-	      return NULL;
+            return NULL;
+		memset(n, 0, sizeof(garmin_list_node));
-	   n->data = data;
+        n->data = data;
-	   n->next = NULL;
+        n->next = NULL;
-	   if ( l->head == NULL )
+        if ( l->head == NULL )
-	      l->head = n;
+            l->head = n;
-	   if ( l->tail != NULL )
+        if ( l->tail != NULL )
-	      l->tail->next = n;
+            l->tail->next = n;
-	   l->tail = n;
+        l->tail = n;
-	   l->elements++;
+        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_data *       ret = NULL;
-  garmin_list *       list;
+garmin_list *       list;
-  garmin_list_node *  n;
+garmin_list_node *  n;
-  unsigned int        i;
+unsigned int        i;
-  if ( data                 != NULL       &&
-       data->type           == data_Dlist &&
-       (list = data->data)  != NULL ) {
+	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 );
+		for ( i = 0, n = list->head; i < which && n != NULL; i++, n = n->next );
-    if ( n != NULL ) ret = n->data;
-  }
+		if ( n != NULL )
+			ret = n->data;
+	}
-  return ret;
+	return ret;
+}
 void
-garmin_free_list ( garmin_list * l )
+garmin_free_list (garmin_list *l)
+{
-  garmin_list_node * n;
+garmin_list_node *n;
-  garmin_list_node * x;
+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);
-  }
+}
 void
 garmin_free_list_only ( garmin_list * l )
+{
-  garmin_list_node * n;
+    garmin_list_node * n;
-  garmin_list_node * x;
+    garmin_list_node * x;
-  if ( l != NULL ) {
+    if ( l != NULL )
+    {
-    for ( n = l->head; n != NULL; n = x ) {
+        for ( n = l->head; n != NULL; n = x )
+        {
-      x = n->next;
+            x = n->next;
+            free ( n );
+        }
-      free(n);
+        free ( l );
+    }
-    free(l);
-  }
+}
 #define TRYFREE(x) if ( x != NULL ) free(x)
 void
 garmin_free_data ( garmin_data * d )
+{
-  D105 *   d105;
+    D105 *   d105;
-  D106 *   d106;
+    D106 *   d106;
-  D108 *   d108;
+    D108 *   d108;
-  D109 *   d109;
+    D109 *   d109;
-  D110 *   d110;
+    D110 *   d110;
-  D202 *   d202;
+    D202 *   d202;
-  D210 *   d210;
+    D210 *   d210;
-  D310 *   d310;
+    D310 *   d310;
-  D312 *   d312;
+    D312 *   d312;
-  D650 *   d650;
+    D650 *   d650;
-  if ( d != NULL ) {
+    if ( d != NULL )
+    {
-    if ( d->data != NULL ) {
+        if ( d->data != NULL )
+        {
-      if ( d->type == data_Dlist ) {
+            if ( d->type == data_Dlist )
+            {
-	garmin_free_list((garmin_list *)d->data);
+                garmin_free_list ( ( garmin_list * ) d->data );
+            }
+            else
-      } else {
+            {
-	switch ( d->type ) {
+                switch ( d->type )
+                {
-	case data_D105:
+                case data_D105:
-	  d105 = d->data;
+                    d105 = d->data;
-	  TRYFREE(d105->wpt_ident);
+                    TRYFREE ( d105->wpt_ident );
-	  break;
+                    break;
-	case data_D106:
+                case data_D106:
-	  d106 = d->data;
+                    d106 = d->data;
-	  TRYFREE(d106->wpt_ident);
+                    TRYFREE ( d106->wpt_ident );
-	  TRYFREE(d106->lnk_ident);
+                    TRYFREE ( d106->lnk_ident );
-	  break;
+                    break;
-	case data_D108:
+                case data_D108:
-	  d108 = d->data;
+                    d108 = d->data;
-	  TRYFREE(d108->ident);
+                    TRYFREE ( d108->ident );
-	  TRYFREE(d108->comment);
+                    TRYFREE ( d108->comment );
-	  TRYFREE(d108->facility);
+                    TRYFREE ( d108->facility );
-	  TRYFREE(d108->city);
+                    TRYFREE ( d108->city );
-	  TRYFREE(d108->addr);
+                    TRYFREE ( d108->addr );
-	  TRYFREE(d108->cross_road);
+                    TRYFREE ( d108->cross_road );
-	  break;
+                    break;
-	case data_D109:
+                case data_D109:
-	  d109 = d->data;
+                    d109 = d->data;
-	  TRYFREE(d109->ident);
+                    TRYFREE ( d109->ident );
-	  TRYFREE(d109->comment);
+                    TRYFREE ( d109->comment );
-	  TRYFREE(d109->facility);
+                    TRYFREE ( d109->facility );
-	  TRYFREE(d109->city);
+                    TRYFREE ( d109->city );
-	  TRYFREE(d109->addr);
+                    TRYFREE ( d109->addr );
-	  TRYFREE(d109->cross_road);
+                    TRYFREE ( d109->cross_road );
-	  break;
+                    break;
-	case data_D110:
+                case data_D110:
-	  d110 = d->data;
+                    d110 = d->data;
-	  TRYFREE(d110->ident);
+                    TRYFREE ( d110->ident );
-	  TRYFREE(d110->comment);
+                    TRYFREE ( d110->comment );
-	  TRYFREE(d110->facility);
+                    TRYFREE ( d110->facility );
-	  TRYFREE(d110->city);
+                    TRYFREE ( d110->city );
-	  TRYFREE(d110->addr);
+                    TRYFREE ( d110->addr );
-	  TRYFREE(d110->cross_road);
+                    TRYFREE ( d110->cross_road );
-	  break;
+                    break;
-	case data_D202:
+                case data_D202:
-	  d202 = d->data;
+                    d202 = d->data;
-	  TRYFREE(d202->rte_ident);
+                    TRYFREE ( d202->rte_ident );
-	  break;
+                    break;
-	case data_D210:
+                case data_D210:
-	  d210 = d->data;
+                    d210 = d->data;
-	  TRYFREE(d210->ident);
+                    TRYFREE ( d210->ident );
-	  break;
+                    break;
-	case data_D310:
+                case data_D310:
-	  d310 = d->data;
+                    d310 = d->data;
-	  TRYFREE(d310->trk_ident);
+                    TRYFREE ( d310->trk_ident );
-	  break;
+                    break;
-	case data_D312:
+                case data_D312:
-	  d312 = d->data;
+                    d312 = d->data;
-	  TRYFREE(d312->trk_ident);
+                    TRYFREE ( d312->trk_ident );
-	  break;
+                    break;
-	case data_D650:
+                case data_D650:
-	  d650 = d->data;
+                    d650 = d->data;
-	  TRYFREE(d650->departure_name);
+                    TRYFREE ( d650->departure_name );
-	  TRYFREE(d650->departure_ident);
+                    TRYFREE ( d650->departure_ident );
-	  TRYFREE(d650->arrival_name);
+                    TRYFREE ( d650->arrival_name );
-	  TRYFREE(d650->arrival_ident);
+                    TRYFREE ( d650->arrival_ident );
-	  TRYFREE(d650->ac_id);
+                    TRYFREE ( d650->ac_id );
-	  break;
+                    break;
-	default:
+                default:
-	  break;
+                    break;
-	}
+                }
-	free(d->data);
+                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
    bytes than the serialized representation will.
 */
   garmin_list *       list;
   garmin_list_node *  node;
   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
      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
      files that include new, unrecognized data types but still conform to
      the file format rules (i.e. we can skip data records that we don't

Subversion Repositories public

(root)/sportwatcher/trunk/libgarmin/datatype.c – Rev 246 → 314