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.

5 files changed, 260 insertions, 231 deletions

diff --git a/glib/glib.h b/glib/glib.h
index 7fc2b543b..b9b16831c 100644
--- a/glib/glib.h
+++ b/glib/glib.h
@@ -959,6 +959,7 @@ void		g_logv			(const gchar	*log_domain,
 					 va_list	*args2);
 GLogLevelFlags	g_log_set_fatal_mask	(const gchar	*log_domain,
 					 GLogLevelFlags	 fatal_mask);
+GLogLevelFlags	g_log_set_always_fatal	(GLogLevelFlags	 fatal_mask);
 #ifndef	G_LOG_DOMAIN
 #define	G_LOG_DOMAIN	(NULL)
 #endif	/* G_LOG_DOMAIN */
diff --git a/glib/gmem.c b/glib/gmem.c
index a3fa6f50a..ace74bc62 100644
--- a/glib/gmem.c
+++ b/glib/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;
diff --git a/glib/gmessages.c b/glib/gmessages.c
index d2937576d..f8271afd3 100644
--- a/glib/gmessages.c
+++ b/glib/gmessages.c
@@ -52,6 +52,7 @@ extern gchar* g_vsprintf (const gchar *fmt,
 /* --- variables --- */
 const gchar	     *g_log_domain_glib = "GLib";
 static GLogDomain    *g_log_domains = NULL;
+static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
 static GPrintFunc     glib_print_func = NULL;
 static GPrintFunc     glib_printerr_func = NULL;
 static GErrorFunc     glib_error_func = NULL;
@@ -141,6 +142,24 @@ g_log_domain_get_handler (GLogDomain	*domain,
 }
 
 GLogLevelFlags
+g_log_set_always_fatal (GLogLevelFlags fatal_mask)
+{
+  GLogLevelFlags old_mask;
+
+  /* restrict the global mask to levels that are known to glib */
+  fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
+  /* force errors to be fatal */
+  fatal_mask |= G_LOG_LEVEL_ERROR;
+  /* remove bogus flag */
+  fatal_mask &= ~G_LOG_FLAG_FATAL;
+
+  old_mask = g_log_always_fatal;
+  g_log_always_fatal = fatal_mask;
+
+  return old_mask;
+}
+
+GLogLevelFlags
 g_log_set_fatal_mask (const gchar    *log_domain,
 		      GLogLevelFlags  fatal_mask)
 {
@@ -271,7 +290,8 @@ g_logv (const gchar    *log_domain,
 	  if (g_log_depth++)
 	    test_level |= G_LOG_FLAG_RECURSION;
 	  
-	  if (((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) & test_level) != 0)
+	  if ((((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) | g_log_always_fatal) &
+	       test_level) != 0)
 	    test_level |= G_LOG_FLAG_FATAL;
 	  log_func = g_log_domain_get_handler (domain, test_level, &data);
 	  log_func (log_domain, test_level, buffer, data);
diff --git a/glib/grel.c b/glib/grel.c
index 979a7d1b2..5fdf88098 100644
--- a/glib/grel.c
+++ b/glib/grel.c
@@ -26,11 +26,11 @@ struct _GRealRelation
 {
   gint fields;
   gint current_field;
-
+  
   GHashTable   *all_tuples;
   GHashTable  **hashed_tuple_tables;
   GMemChunk    *tuple_chunk;
-
+  
   gint count;
 };
 
@@ -47,7 +47,7 @@ tuple_equal_2 (gconstpointer v_a,
 {
   gpointer* a = (gpointer*) v_a;
   gpointer* b = (gpointer*) v_b;
-
+  
   return a[0] == b[0] && a[1] == b[1];
 }
 
@@ -55,7 +55,7 @@ static guint
 tuple_hash_2 (gconstpointer v_a)
 {
   gpointer* a = (gpointer*) v_a;
-
+  
   return (gulong)a[0] ^ (gulong)a[1];
 }
 
@@ -69,7 +69,7 @@ tuple_hash (gint fields)
     default:
       g_error ("no tuple hash for %d", fields);
     }
-
+  
   return NULL;
 }
 
@@ -83,7 +83,7 @@ tuple_equal (gint fields)
     default:
       g_error ("no tuple equal for %d", fields);
     }
-
+  
   return NULL;
 }
 
@@ -91,7 +91,7 @@ GRelation*
 g_relation_new (gint fields)
 {
   GRealRelation* rel = g_new0 (GRealRelation, 1);
-
+  
   rel->fields = fields;
   rel->tuple_chunk = g_mem_chunk_new ("Relation Chunk",
 				      fields * sizeof (gpointer),
@@ -99,7 +99,7 @@ g_relation_new (gint fields)
 				      G_ALLOC_AND_FREE);
   rel->all_tuples = g_hash_table_new (tuple_hash (fields), tuple_equal (fields));
   rel->hashed_tuple_tables = g_new0 (GHashTable*, fields);
-
+  
   return (GRelation*) rel;
 }
 
@@ -114,12 +114,12 @@ g_relation_destroy (GRelation *relation)
 {
   GRealRelation *rel = (GRealRelation *) relation;
   gint i;
-
+  
   if (rel)
     {
       g_hash_table_destroy (rel->all_tuples);
       g_mem_chunk_destroy (rel->tuple_chunk);
-
+      
       for (i = 0; i < rel->fields; i += 1)
 	{
 	  if (rel->hashed_tuple_tables[i])
@@ -128,7 +128,7 @@ g_relation_destroy (GRelation *relation)
 	      g_hash_table_destroy (rel->hashed_tuple_tables[i]);
 	    }
 	}
-
+      
       g_free (rel->hashed_tuple_tables);
       g_free (rel);
     }
@@ -141,9 +141,9 @@ g_relation_index (GRelation   *relation,
 		  GCompareFunc key_compare_func)
 {
   GRealRelation *rel = (GRealRelation *) relation;
-
+  
   g_assert (rel->count == 0 && rel->hashed_tuple_tables[field] == NULL);
-
+  
   rel->hashed_tuple_tables[field] = g_hash_table_new (hash_func, key_compare_func);
 }
 
@@ -155,38 +155,38 @@ g_relation_insert (GRelation   *relation,
   gpointer* tuple = g_chunk_new (gpointer, rel->tuple_chunk);
   va_list args;
   gint i;
-
+  
   va_start(args, relation);
-
+  
   for (i = 0; i < rel->fields; i += 1)
     tuple[i] = va_arg(args, gpointer);
-
+  
   va_end(args);
-
+  
   g_hash_table_insert (rel->all_tuples, tuple, tuple);
-
+  
   rel->count += 1;
-
+  
   for (i = 0; i < rel->fields; i += 1)
     {
       GHashTable *table;
       gpointer    key;
       GHashTable *per_key_table;
-
+      
       table = rel->hashed_tuple_tables[i];
-
+      
       if (table == NULL)
 	continue;
-
+      
       key = tuple[i];
       per_key_table = g_hash_table_lookup (table, key);
-
+      
       if (per_key_table == NULL)
 	{
 	  per_key_table = g_hash_table_new (tuple_hash (rel->fields), tuple_equal (rel->fields));
 	  g_hash_table_insert (table, key, per_key_table);
 	}
-
+      
       g_hash_table_insert (per_key_table, tuple, tuple);
     }
 }
@@ -197,31 +197,31 @@ g_relation_delete_tuple (gpointer tuple_key, gpointer tuple_value, gpointer user
   gpointer      *tuple = (gpointer*) tuple_value;
   GRealRelation *rel = (GRealRelation *) user_data;
   gint           j;
-
+  
   g_assert (tuple_key == tuple_value);
-
+  
   for (j = 0; j < rel->fields; j += 1)
     {
       GHashTable *one_table = rel->hashed_tuple_tables[j];
       gpointer    one_key;
       GHashTable *per_key_table;
-
+      
       if (one_table == NULL)
 	continue;
-
+      
       if (j == rel->current_field)
 	/* can't delete from the table we're foreaching in */
 	continue;
-
+      
       one_key = tuple[j];
-
+      
       per_key_table = g_hash_table_lookup (one_table, one_key);
-
+      
       g_hash_table_remove (per_key_table, tuple);
     }
-
+  
   g_hash_table_remove (rel->all_tuples, tuple);
-
+  
   rel->count -= 1;
 }
 
@@ -234,24 +234,24 @@ g_relation_delete  (GRelation   *relation,
   GHashTable *table = rel->hashed_tuple_tables[field];
   GHashTable *key_table;
   gint        count = rel->count;
-
+  
   g_assert (table);
-
+  
   key_table = g_hash_table_lookup (table, key);
-
+  
   if (!key_table)
     return 0;
-
+  
   rel->current_field = field;
-
+  
   g_hash_table_foreach (key_table, g_relation_delete_tuple, rel);
-
+  
   g_hash_table_remove (table, key);
-
+  
   g_hash_table_destroy (key_table);
-
-  /* @@@ Remove empty hash tables. */
-
+  
+  /* @@@ FIXME: Remove empty hash tables. */
+  
   return count - rel->count;
 }
 
@@ -261,13 +261,13 @@ g_relation_select_tuple (gpointer tuple_key, gpointer tuple_value, gpointer user
   gpointer    *tuple = (gpointer*) tuple_value;
   GRealTuples *tuples = (GRealTuples*) user_data;
   gint stride = sizeof (gpointer) * tuples->width;
-
+  
   g_assert (tuple_key == tuple_value);
-
+  
   memcpy (tuples->data + (tuples->len * tuples->width),
 	  tuple,
 	  stride);
-
+  
   tuples->len += 1;
 }
 
@@ -281,23 +281,23 @@ g_relation_select (GRelation   *relation,
   GHashTable  *key_table;
   GRealTuples *tuples = g_new0 (GRealTuples, 1);
   gint count;
-
+  
   g_assert (table);
-
+  
   key_table = g_hash_table_lookup (table, key);
-
+  
   if (!key_table)
     return (GTuples*)tuples;
-
+  
   count = g_relation_count (relation, key, field);
-
+  
   tuples->data = g_malloc (sizeof (gpointer) * rel->fields * count);
   tuples->width = rel->fields;
-
+  
   g_hash_table_foreach (key_table, g_relation_select_tuple, tuples);
-
+  
   g_assert (count == tuples->len);
-
+  
   return (GTuples*)tuples;
 }
 
@@ -309,14 +309,14 @@ g_relation_count (GRelation   *relation,
   GRealRelation *rel = (GRealRelation *) relation;
   GHashTable  *table = rel->hashed_tuple_tables[field];
   GHashTable  *key_table;
-
+  
   g_assert (table);
-
+  
   key_table = g_hash_table_lookup (table, key);
-
+  
   if (!key_table)
     return 0;
-
+  
   return g_hash_table_size (key_table);
 }
 
@@ -328,18 +328,18 @@ g_relation_exists (GRelation   *relation, ...)
   va_list args;
   gint i;
   gboolean result;
-
+  
   va_start(args, relation);
-
+  
   for (i = 0; i < rel->fields; i += 1)
     tuple[i] = va_arg(args, gpointer);
-
+  
   va_end(args);
-
+  
   result = g_hash_table_lookup (rel->all_tuples, tuple) != NULL;
-
+  
   g_mem_chunk_free (rel->tuple_chunk, tuple);
-
+  
   return result;
 }
 
@@ -347,7 +347,7 @@ void
 g_tuples_destroy (GTuples *tuples0)
 {
   GRealTuples *tuples = (GRealTuples*) tuples0;
-
+  
   if (tuples)
     {
       g_free (tuples->data);
@@ -361,9 +361,9 @@ g_tuples_index (GTuples     *tuples0,
 		gint         field)
 {
   GRealTuples *tuples = (GRealTuples*) tuples0;
-
+  
   g_assert (field < tuples->width);
-
+  
   return tuples->data[index * tuples->width + field];
 }
 
@@ -376,20 +376,23 @@ g_relation_print_one (gpointer tuple_key,
 		      gpointer user_data)
 {
   gint i;
+  GString *gstring;
   GRealRelation* rel = (GRealRelation*) user_data;
   gpointer* tuples = (gpointer*) tuple_value;
 
-  g_print ("[");
-
+  gstring = g_string_new ("[");
+  
   for (i = 0; i < rel->fields; i += 1)
     {
-      g_print ("%p", tuples[i]);
-
+      g_string_sprintfa (gstring, "%p", tuples[i]);
+      
       if (i < (rel->fields - 1))
-	g_print (",");
+	g_string_append (gstring, ",");
     }
-
-  g_print ("]\n");
+  
+  g_string_append (gstring, "]");
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, gstring->str);
+  g_string_free (gstring, TRUE);
 }
 
 static void
@@ -399,9 +402,9 @@ g_relation_print_index (gpointer tuple_key,
 {
   GRealRelation* rel = (GRealRelation*) user_data;
   GHashTable* table = (GHashTable*) tuple_value;
-
-  g_print ("*** key %p\n", tuple_key);
-
+  
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** key %p", tuple_key);
+  
   g_hash_table_foreach (table,
 			g_relation_print_one,
 			rel);
@@ -412,23 +415,23 @@ g_relation_print (GRelation *relation)
 {
   gint i;
   GRealRelation* rel = (GRealRelation*) relation;
-
-  g_print ("*** all tuples (%d)\n", rel->count);
-
+  
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** all tuples (%d)", rel->count);
+  
   g_hash_table_foreach (rel->all_tuples,
 			g_relation_print_one,
 			rel);
-
+  
   for (i = 0; i < rel->fields; i += 1)
     {
       if (rel->hashed_tuple_tables[i] == NULL)
 	continue;
-
-      g_print ("*** index %d\n", i);
-
+      
+      g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** index %d", i);
+      
       g_hash_table_foreach (rel->hashed_tuple_tables[i],
 			    g_relation_print_index,
 			    rel);
     }
-
+  
 }
diff --git a/glib/gtree.c b/glib/gtree.c
index 2a3dd8fa4..00bfb14c0 100644
--- a/glib/gtree.c
+++ b/glib/gtree.c
@@ -699,22 +699,23 @@ g_tree_node_check (GTreeNode *node)
   gint left_height;
   gint right_height;
   gint balance;
-
+  
   if (node)
     {
       left_height = 0;
       right_height = 0;
-
+      
       if (node->left)
 	left_height = g_tree_node_height (node->left);
       if (node->right)
 	right_height = g_tree_node_height (node->right);
-
+      
       balance = right_height - left_height;
       if (balance != node->balance)
-	g_print ("g_tree_node_check: failed: %d ( %d )\n",
-		 balance, node->balance);
-
+	g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	       "g_tree_node_check: failed: %d ( %d )\n",
+	       balance, node->balance);
+      
       if (node->left)
 	g_tree_node_check (node->left);
       if (node->right)