new function g_log_set_always_fatal() to set an additional fatal_mask for

Tue Aug 18 04:40:17 1998  Tim Janik  <timj@gtk.org>

        * glib.h:
        * gmessages.c: new function g_log_set_always_fatal() to set an
        additional fatal_mask for log levels that are considered to be fatal
        globally (required by gtk). since this mask is not domain-associated,
        it is restricted to the log levels, introduced by glib itself.

        * gmem.c:
        * grel.c:
        * gtree.c (g_tree_node_check):
        don't use g_print() calls for informational/debugging output,
        but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
        libraries shouldn't use printf(), g_print() or g_printerr() at all.

1 files changed, 143 insertions, 139 deletions

diff --git a/gmem.c b/gmem.c
index a3fa6f50a..ace74bc62 100644
--- a/gmem.c
+++ b/gmem.c
@@ -100,46 +100,46 @@ gpointer
 g_malloc (gulong size)
 {
   gpointer p;
-
-
+  
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   gulong *t;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+  
+  
   if (size == 0)
     return NULL;
-
-
+  
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+  
 #ifdef ENABLE_MEM_CHECK
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_CHECK */
-
-
+  
+  
   p = (gpointer) malloc (size);
   if (!p)
     g_error ("could not allocate %ld bytes", size);
-
-
+  
+  
 #ifdef ENABLE_MEM_CHECK
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = 0;
 #endif /* ENABLE_MEM_CHECK */
-
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = size;
-
+  
 #ifdef ENABLE_MEM_PROFILE
   if (size <= 4095)
     allocations[size-1] += 1;
@@ -148,8 +148,8 @@ g_malloc (gulong size)
   allocated_mem += size;
 #endif /* ENABLE_MEM_PROFILE */
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+  
+  
   return p;
 }
 
@@ -157,46 +157,46 @@ gpointer
 g_malloc0 (gulong size)
 {
   gpointer p;
-
-
+  
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   gulong *t;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+  
+  
   if (size == 0)
     return NULL;
-
-
+  
+  
 #ifdef ENABLE_MEM_PROFILE
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_PROFILE */
-
+  
 #ifdef ENABLE_MEM_CHECK
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_CHECK */
-
-
+  
+  
   p = (gpointer) calloc (size, 1);
   if (!p)
     g_error ("could not allocate %ld bytes", size);
-
-
+  
+  
 #ifdef ENABLE_MEM_CHECK
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = 0;
 #endif /* ENABLE_MEM_CHECK */
-
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = size;
-
+  
 #ifdef ENABLE_MEM_PROFILE
   if (size <= 4095)
     allocations[size-1] += 1;
@@ -205,8 +205,8 @@ g_malloc0 (gulong size)
   allocated_mem += size;
 #endif /* ENABLE_MEM_PROFILE */
 #endif /* ENABLE_MEM_PROFILE */
-
-
+  
+  
   return p;
 }
 
@@ -215,25 +215,25 @@ g_realloc (gpointer mem,
 	   gulong   size)
 {
   gpointer p;
-
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   gulong *t;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+  
+  
   if (size == 0)
     return NULL;
-
-
+  
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+  
 #ifdef ENABLE_MEM_CHECK
   size += SIZEOF_LONG;
 #endif /* ENABLE_MEM_CHECK */
-
-
+  
+  
   if (!mem)
     p = (gpointer) malloc (size);
   else
@@ -245,36 +245,36 @@ g_realloc (gpointer mem,
 #endif /* ENABLE_MEM_PROFILE */
       mem = t;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+      
 #ifdef ENABLE_MEM_CHECK
       t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
       if (*t >= 1)
 	g_warning ("trying to realloc freed memory\n");
       mem = t;
 #endif /* ENABLE_MEM_CHECK */
-
+      
       p = (gpointer) realloc (mem, size);
     }
-
+  
   if (!p)
     g_error ("could not reallocate %ld bytes", size);
-
-
+  
+  
 #ifdef ENABLE_MEM_CHECK
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = 0;
 #endif /* ENABLE_MEM_CHECK */
-
+  
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
   size -= SIZEOF_LONG;
-
+  
   t = p;
   p = ((guchar*) p + SIZEOF_LONG);
   *t = size;
-
+  
 #ifdef ENABLE_MEM_PROFILE
   if (size <= 4095)
     allocations[size-1] += 1;
@@ -283,8 +283,8 @@ g_realloc (gpointer mem,
   allocated_mem += size;
 #endif /* ENABLE_MEM_PROFILE */
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+  
+  
   return p;
 }
 
@@ -297,7 +297,7 @@ g_free (gpointer mem)
       gulong *t;
       gulong size;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+      
 #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
       t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
       size = *t;
@@ -306,14 +306,14 @@ g_free (gpointer mem)
 #endif /* ENABLE_MEM_PROFILE */
       mem = t;
 #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+      
 #ifdef ENABLE_MEM_CHECK
       t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
       if (*t >= 1)
 	g_warning ("freeing previously freed memory\n");
       *t += 1;
       mem = t;
-
+      
       memset ((guchar*) mem + 8, 0, size);
 #else /* ENABLE_MEM_CHECK */
       free (mem);
@@ -329,16 +329,18 @@ g_mem_profile (void)
 {
 #ifdef ENABLE_MEM_PROFILE
   gint i;
-
+  
   for (i = 0; i < 4095; i++)
     if (allocations[i] > 0)
-      g_print ("%lu allocations of %d bytes\n", allocations[i], i + 1);
-
+      g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	     "%lu allocations of %d bytes\n", allocations[i], i + 1);
+  
   if (allocations[4095] > 0)
-    g_print ("%lu allocations of greater than 4095 bytes\n", allocations[4095]);
-  g_print ("%lu bytes allocated\n", allocated_mem);
-  g_print ("%lu bytes freed\n", freed_mem);
-  g_print ("%lu bytes in use\n", allocated_mem - freed_mem);
+    g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	   "%lu allocations of greater than 4095 bytes\n", allocations[4095]);
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes allocated\n", allocated_mem);
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes freed\n", freed_mem);
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes in use\n", allocated_mem - freed_mem);
 #endif /* ENABLE_MEM_PROFILE */
 }
 
@@ -347,9 +349,9 @@ g_mem_check (gpointer mem)
 {
 #ifdef ENABLE_MEM_CHECK
   gulong *t;
-
+  
   t = (gulong*) ((guchar*) mem - SIZEOF_LONG - SIZEOF_LONG);
-
+  
   if (*t >= 1)
     g_warning ("mem: 0x%08x has been freed: %lu\n", (gulong) mem, *t);
 #endif /* ENABLE_MEM_CHECK */
@@ -363,7 +365,7 @@ g_mem_chunk_new (gchar  *name,
 {
   GRealMemChunk *mem_chunk;
   gulong rarea_size;
-
+  
   mem_chunk = g_new (struct _GRealMemChunk, 1);
   mem_chunk->name = name;
   mem_chunk->type = type;
@@ -375,41 +377,41 @@ g_mem_chunk_new (gchar  *name,
   mem_chunk->mem_tree = NULL;
   mem_chunk->mem_areas = NULL;
   mem_chunk->atom_size = atom_size;
-
+  
   if (mem_chunk->type == G_ALLOC_AND_FREE)
     mem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
-
+  
   if (mem_chunk->atom_size % MEM_ALIGN)
     mem_chunk->atom_size += MEM_ALIGN - (mem_chunk->atom_size % MEM_ALIGN);
-
+  
   mem_chunk->area_size = area_size;
   if (mem_chunk->area_size > MAX_MEM_AREA)
     mem_chunk->area_size = MAX_MEM_AREA;
   while (mem_chunk->area_size < mem_chunk->atom_size)
     mem_chunk->area_size *= 2;
-
+  
   rarea_size = mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE;
   rarea_size = g_mem_chunk_compute_size (rarea_size);
   mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE);
-
+  
   /*
-  mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
-  if (mem_chunk->area_size < mem_chunk->atom_size)
+    mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+    if (mem_chunk->area_size < mem_chunk->atom_size)
     {
-      mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
-      mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+    mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
+    mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
     }
-
-  if (mem_chunk->area_size % mem_chunk->atom_size)
+    
+    if (mem_chunk->area_size % mem_chunk->atom_size)
     mem_chunk->area_size += mem_chunk->atom_size - (mem_chunk->area_size % mem_chunk->atom_size);
-    */
-
+  */
+  
   mem_chunk->next = mem_chunks;
   mem_chunk->prev = NULL;
   if (mem_chunks)
     mem_chunks->prev = mem_chunk;
   mem_chunks = mem_chunk;
-
+  
   return ((GMemChunk*) mem_chunk);
 }
 
@@ -419,11 +421,11 @@ g_mem_chunk_destroy (GMemChunk *mem_chunk)
   GRealMemChunk *rmem_chunk;
   GMemArea *mem_areas;
   GMemArea *temp_area;
-
+  
   g_assert (mem_chunk != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+  
   mem_areas = rmem_chunk->mem_areas;
   while (mem_areas)
     {
@@ -431,18 +433,18 @@ g_mem_chunk_destroy (GMemChunk *mem_chunk)
       mem_areas = mem_areas->next;
       g_free (temp_area);
     }
-
+  
   if (rmem_chunk->next)
     rmem_chunk->next->prev = rmem_chunk->prev;
   if (rmem_chunk->prev)
     rmem_chunk->prev->next = rmem_chunk->next;
-
+  
   if (rmem_chunk == mem_chunks)
     mem_chunks = mem_chunks->next;
-
+  
   if (rmem_chunk->type == G_ALLOC_AND_FREE)
     g_tree_destroy (rmem_chunk->mem_tree);
-
+  
   g_free (rmem_chunk);
 }
 
@@ -452,11 +454,11 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk)
   GRealMemChunk *rmem_chunk;
   GMemArea *temp_area;
   gpointer mem;
-
+  
   g_assert (mem_chunk != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+  
   while (rmem_chunk->free_atoms)
     {
       /* Get the first piece of memory on the "free_atoms" list.
@@ -466,12 +468,12 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk)
        */
       mem = rmem_chunk->free_atoms;
       rmem_chunk->free_atoms = rmem_chunk->free_atoms->next;
-
+      
       /* Determine which area this piece of memory is allocated from */
       temp_area = g_tree_search (rmem_chunk->mem_tree,
 				 (GSearchFunc) g_mem_chunk_area_search,
 				 mem);
-
+      
       /* If the area has been marked, then it is being destroyed.
        *  (ie marked to be destroyed).
        * We check to see if all of the segments on the free list that
@@ -488,23 +490,23 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk)
         {
           /* Update the "free" memory available in that area */
           temp_area->free += rmem_chunk->atom_size;
-
+	  
           if (temp_area->free == rmem_chunk->area_size)
             {
               if (temp_area == rmem_chunk->mem_area)
                 rmem_chunk->mem_area = NULL;
-
+	      
               if (rmem_chunk->free_mem_area)
                 {
                   rmem_chunk->num_mem_areas -= 1;
-
+		  
                   if (temp_area->next)
                     temp_area->next->prev = temp_area->prev;
                   if (temp_area->prev)
                     temp_area->prev->next = temp_area->next;
                   if (temp_area == rmem_chunk->mem_areas)
                     rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
-
+		  
 		  if (rmem_chunk->type == G_ALLOC_AND_FREE)
 		    g_tree_remove (rmem_chunk->mem_tree, temp_area);
                   g_free (temp_area);
@@ -520,13 +522,13 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk)
           /* Update the number of allocated atoms count.
 	   */
           temp_area->allocated += 1;
-
+	  
           /* The area wasn't marked...return the memory
 	   */
 	  goto outa_here;
         }
     }
-
+  
   /* If there isn't a current mem area or the current mem area is out of space
    *  then allocate a new mem area. We'll first check and see if we can use
    *  the "free_mem_area". Otherwise we'll just malloc the mem area.
@@ -544,33 +546,33 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk)
 	  rmem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) -
 						       MEM_AREA_SIZE +
 						       rmem_chunk->area_size);
-
+	  
 	  rmem_chunk->num_mem_areas += 1;
 	  rmem_chunk->mem_area->next = rmem_chunk->mem_areas;
 	  rmem_chunk->mem_area->prev = NULL;
-
+	  
 	  if (rmem_chunk->mem_areas)
 	    rmem_chunk->mem_areas->prev = rmem_chunk->mem_area;
 	  rmem_chunk->mem_areas = rmem_chunk->mem_area;
-
+	  
 	  if (rmem_chunk->type == G_ALLOC_AND_FREE)
 	    g_tree_insert (rmem_chunk->mem_tree, rmem_chunk->mem_area, rmem_chunk->mem_area);
         }
-
+      
       rmem_chunk->mem_area->index = 0;
       rmem_chunk->mem_area->free = rmem_chunk->area_size;
       rmem_chunk->mem_area->allocated = 0;
       rmem_chunk->mem_area->mark = 0;
     }
-
+  
   /* Get the memory and modify the state variables appropriately.
    */
   mem = (gpointer) &rmem_chunk->mem_area->mem[rmem_chunk->mem_area->index];
   rmem_chunk->mem_area->index += rmem_chunk->atom_size;
   rmem_chunk->mem_area->free -= rmem_chunk->atom_size;
   rmem_chunk->mem_area->allocated += 1;
-
-outa_here:
+  
+ outa_here:
   return mem;
 }
 
@@ -581,12 +583,12 @@ g_mem_chunk_free (GMemChunk *mem_chunk,
   GRealMemChunk *rmem_chunk;
   GMemArea *temp_area;
   GFreeAtom *free_atom;
-
+  
   g_assert (mem_chunk != NULL);
   g_assert (mem != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+  
   /* Don't do anything if this is an ALLOC_ONLY chunk
    */
   if (rmem_chunk->type == G_ALLOC_AND_FREE)
@@ -596,13 +598,13 @@ g_mem_chunk_free (GMemChunk *mem_chunk,
       free_atom = (GFreeAtom*) mem;
       free_atom->next = rmem_chunk->free_atoms;
       rmem_chunk->free_atoms = free_atom;
-
+      
       temp_area = g_tree_search (rmem_chunk->mem_tree,
 				 (GSearchFunc) g_mem_chunk_area_search,
 				 mem);
-
+      
       temp_area->allocated -= 1;
-
+      
       if (temp_area->allocated == 0)
 	{
 	  temp_area->mark = 1;
@@ -620,24 +622,24 @@ g_mem_chunk_clean (GMemChunk *mem_chunk)
   GFreeAtom *prev_free_atom;
   GFreeAtom *temp_free_atom;
   gpointer mem;
-
+  
   g_assert (mem_chunk != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+  
   if (rmem_chunk->type == G_ALLOC_AND_FREE)
     {
       prev_free_atom = NULL;
       temp_free_atom = rmem_chunk->free_atoms;
-
+      
       while (temp_free_atom)
 	{
 	  mem = (gpointer) temp_free_atom;
-
+	  
 	  mem_area = g_tree_search (rmem_chunk->mem_tree,
 				    (GSearchFunc) g_mem_chunk_area_search,
 				    mem);
-
+	  
           /* If this mem area is marked for destruction then delete the
 	   *  area and list node and decrement the free mem.
            */
@@ -648,13 +650,13 @@ g_mem_chunk_clean (GMemChunk *mem_chunk)
 	      else
 		rmem_chunk->free_atoms = temp_free_atom->next;
 	      temp_free_atom = temp_free_atom->next;
-
+	      
 	      mem_area->free += rmem_chunk->atom_size;
 	      if (mem_area->free == rmem_chunk->area_size)
 		{
 		  rmem_chunk->num_mem_areas -= 1;
 		  rmem_chunk->num_marked_areas -= 1;
-
+		  
 		  if (mem_area->next)
 		    mem_area->next->prev = mem_area->prev;
 		  if (mem_area->prev)
@@ -663,7 +665,7 @@ g_mem_chunk_clean (GMemChunk *mem_chunk)
 		    rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
 		  if (mem_area == rmem_chunk->mem_area)
 		    rmem_chunk->mem_area = NULL;
-
+		  
 		  if (rmem_chunk->type == G_ALLOC_AND_FREE)
 		    g_tree_remove (rmem_chunk->mem_tree, mem_area);
 		  g_free (mem_area);
@@ -684,25 +686,25 @@ g_mem_chunk_reset (GMemChunk *mem_chunk)
   GRealMemChunk *rmem_chunk;
   GMemArea *mem_areas;
   GMemArea *temp_area;
-
+  
   g_assert (mem_chunk != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+  
   mem_areas = rmem_chunk->mem_areas;
   rmem_chunk->num_mem_areas = 0;
   rmem_chunk->mem_areas = NULL;
   rmem_chunk->mem_area = NULL;
-
+  
   while (mem_areas)
     {
       temp_area = mem_areas;
       mem_areas = mem_areas->next;
       g_free (temp_area);
     }
-
+  
   rmem_chunk->free_atoms = NULL;
-
+  
   if (rmem_chunk->mem_tree)
     g_tree_destroy (rmem_chunk->mem_tree);
   rmem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
@@ -714,20 +716,22 @@ g_mem_chunk_print (GMemChunk *mem_chunk)
   GRealMemChunk *rmem_chunk;
   GMemArea *mem_areas;
   gulong mem;
-
+  
   g_assert (mem_chunk != NULL);
-
+  
   rmem_chunk = (GRealMemChunk*) mem_chunk;
   mem_areas = rmem_chunk->mem_areas;
   mem = 0;
-
+  
   while (mem_areas)
     {
       mem += rmem_chunk->area_size - mem_areas->free;
       mem_areas = mem_areas->next;
     }
-
-  g_print ("%s: %ld bytes using %d mem areas\n", rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
+  
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	 "%s: %ld bytes using %d mem areas\n",
+	 rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
 }
 
 void
@@ -735,7 +739,7 @@ g_mem_chunk_info (void)
 {
   GRealMemChunk *mem_chunk;
   gint count;
-
+  
   count = 0;
   mem_chunk = mem_chunks;
   while (mem_chunk)
@@ -743,9 +747,9 @@ g_mem_chunk_info (void)
       count += 1;
       mem_chunk = mem_chunk->next;
     }
-
-  g_print ("%d mem chunks\n", count);
-
+  
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks\n", count);
+  
   mem_chunk = mem_chunks;
   while (mem_chunk)
     {
@@ -758,7 +762,7 @@ void
 g_blow_chunks (void)
 {
   GRealMemChunk *mem_chunk;
-
+  
   mem_chunk = mem_chunks;
   while (mem_chunk)
     {
@@ -773,14 +777,14 @@ g_mem_chunk_compute_size (gulong size)
 {
   gulong power_of_2;
   gulong lower, upper;
-
+  
   power_of_2 = 16;
   while (power_of_2 < size)
     power_of_2 <<= 1;
-
+  
   lower = power_of_2 >> 1;
   upper = power_of_2;
-
+  
   if ((size - lower) < (upper - size))
     return lower;
   return upper;