Index: configure.in
===================================================================
RCS file: /export/cvs/head/gconf/configure.in,v
retrieving revision 1.224
diff -p -u -5 -r1.224 configure.in
--- configure.in	17 Apr 2006 11:50:32 -0000	1.224
+++ configure.in	4 May 2006 11:20:06 -0000
@@ -137,10 +137,13 @@ fi
 
 GTK_DOC_CHECK([1.0])
 
 AC_ARG_ENABLE(gtk, [  --enable-gtk          Enable GTK+ support (for gconf-sanity-check) [default=auto]], enable_gtk="$enableval", enable_gtk=auto)
 
+LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^[[^_]].*"'
+AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
+
 PKGCONFIG_MODULES='glib-2.0 > 2.9.0 gmodule-2.0 >= 2.7.0 gobject-2.0 >= 2.7.0 ORBit-2.0 >= 2.4.0'
 PKGCONFIG_MODULES_WITH_XML="$PKGCONFIG_MODULES libxml-2.0"
 PKGCONFIG_MODULES_WITH_GTK=" $PKGCONFIG_MODULES gtk+-2.0 >= 2.0.0"
 PKGCONFIG_MODULES_WITH_XML_AND_GTK=" $PKGCONFIG_MODULES gtk+-2.0 libxml-2.0"
 
Index: gconf/Makefile.am
===================================================================
RCS file: /export/cvs/head/gconf/gconf/Makefile.am,v
retrieving revision 1.82
diff -p -u -5 -r1.82 Makefile.am
--- gconf/Makefile.am	9 Jun 2005 23:53:02 -0000	1.82
+++ gconf/Makefile.am	4 May 2006 11:20:27 -0000
@@ -33,10 +33,11 @@ lib_LTLIBRARIES = libgconf-2.la
 
 bin_PROGRAMS = gconftool-2 
 libexec_PROGRAMS = gconfd-2 $(SANITY_CHECK)
 
 CORBA_SOURCECODE = GConfX-common.c GConfX-skels.c GConfX-stubs.c GConfX.h
+export_symbols = $(LIBTOOL_EXPORT_OPTIONS)
 
 BUILT_SOURCES = 			\
 	$(CORBA_SOURCECODE)		\
 	gconfmarshal.h			\
 	gconfmarshal.c
@@ -113,11 +114,14 @@ libgconf_2_la_SOURCES = \
 	gconf-client.c		\
 	gconf-enum-types.c	\
 	$(CORBA_SOURCECODE)	\
 	$(WIN32_SOURCECODE)
 
-libgconf_2_la_LDFLAGS = -version-info $(GCONF_CURRENT):$(GCONF_REVISION):$(GCONF_AGE) -no-undefined
+libgconf_2_la_LDFLAGS = -version-info $(GCONF_CURRENT):$(GCONF_REVISION):$(GCONF_AGE) \
+			-no-undefined \
+			$(export_symbols) \
+			$(NULL)
 
 libgconf_2_la_LIBADD = $(INTLLIBS) $(DEPENDENT_LIBS)
 
 EXTRA_DIST=GConfX.idl default.path.in gconfmarshal.list regenerate-enum-header.sh regenerate-enum-footer.sh
 
Index: backends/evoldap-backend.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/evoldap-backend.c,v
retrieving revision 1.3
diff -p -u -5 -r1.3 evoldap-backend.c
--- backends/evoldap-backend.c	10 Aug 2005 08:40:31 -0000	1.3
+++ backends/evoldap-backend.c	4 May 2006 11:20:55 -0000
@@ -149,11 +149,11 @@ resolve_address (const char  *address,
 		 GError     **err)
 {
   EvoSource *esource;
   char      *conf_file;
 
-  if ((conf_file = gconf_address_resource (address)) == NULL)
+  if ((conf_file = _gconf_address_resource (address)) == NULL)
     {
       g_set_error (err, GCONF_ERROR,
 		   GCONF_ERROR_BAD_ADDRESS,
 		   _("Failed to get configuration file path from '%s'"),
 		   address);
@@ -628,11 +628,11 @@ build_value_from_entries (LDAP        *c
       char       *str;
 
       str = subst_variables_into_template (connection, entry, template_node);
 
       value = gconf_value_new (GCONF_VALUE_STRING);
-      gconf_value_set_string_nocopy (value, str);
+      _gconf_value_set_string_nocopy (value, str);
 
       values = g_slist_append (values, value);
 
       entry = ldap_next_entry (connection, entry);
     }
Index: backends/markup-tree.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/markup-tree.c,v
retrieving revision 1.23
diff -p -u -5 -r1.23 markup-tree.c
--- backends/markup-tree.c	10 Mar 2006 01:59:33 -0000	1.23
+++ backends/markup-tree.c	4 May 2006 11:20:55 -0000
@@ -493,11 +493,11 @@ load_subtree (MarkupDir *dir)
 
   GError *tmp_err = NULL;
   char *markup_file;
 
   markup_file = markup_dir_build_file_path (dir, TRUE, NULL);
-  if (!gconf_file_exists (markup_file))
+  if (!_gconf_file_exists (markup_file))
     {
       g_free (markup_file);
       return FALSE;
     }
 
@@ -2302,11 +2302,11 @@ float_from_string (GMarkupParseContext *
                    double              *val,
                    GError             **error)
 {
   double num;
 
-  if (gconf_string_to_double (str, &num))
+  if (_gconf_string_to_double (str, &num))
     {
       *val = num;
       return TRUE;
     }
   else
@@ -2386,11 +2386,11 @@ parse_value_element (GMarkupParseContext
                  _("No \"%s\" attribute on element <%s>"),
                  "type", element_name);
       return;
     }
   
-  vtype = gconf_value_type_from_string (type);
+  vtype = _gconf_value_type_from_string (type);
   if (vtype == GCONF_VALUE_INVALID)
     {
       set_error (error, context, GCONF_ERROR_PARSE_ERROR,
                  _("Unknown value \"%s\" for \"%s\" attribute on element <%s>"),
                  type, "type", element_name);
@@ -2415,11 +2415,11 @@ parse_value_element (GMarkupParseContext
                        _("No \"%s\" attribute on element <%s>"),
                        "ltype", element_name);
             return;
           }
 
-        lvtype = gconf_value_type_from_string (ltype);
+        lvtype = _gconf_value_type_from_string (ltype);
 
         switch (lvtype)
           {
           case GCONF_VALUE_INVALID:
           case GCONF_VALUE_LIST:
@@ -2460,11 +2460,11 @@ parse_value_element (GMarkupParseContext
         /* init for compiler warnings */
         car_vtype = GCONF_VALUE_INVALID;
         cdr_vtype = GCONF_VALUE_INVALID;
         list_vtype = GCONF_VALUE_INVALID;
 
-        schema_vtype = gconf_value_type_from_string (stype);
+        schema_vtype = _gconf_value_type_from_string (stype);
 
         if (schema_vtype == GCONF_VALUE_PAIR)
           {
             
 #if 0
@@ -2489,16 +2489,16 @@ parse_value_element (GMarkupParseContext
                 return;
               }
 #endif
 
             if (car_type)
-              car_vtype = gconf_value_type_from_string (car_type);
+              car_vtype = _gconf_value_type_from_string (car_type);
             else
               car_vtype = GCONF_VALUE_INVALID;
 
             if (cdr_vtype)
-              cdr_vtype = gconf_value_type_from_string (cdr_type);
+              cdr_vtype = _gconf_value_type_from_string (cdr_type);
             else
               cdr_vtype = GCONF_VALUE_INVALID;
 
             switch (car_vtype)
               {
@@ -2544,11 +2544,11 @@ parse_value_element (GMarkupParseContext
                 return;
               }
 #endif
 
             if (list_type)
-              list_vtype = gconf_value_type_from_string (list_type);
+              list_vtype = _gconf_value_type_from_string (list_type);
             else
               list_vtype = GCONF_VALUE_INVALID;
 
             switch (list_vtype)
               {
@@ -2754,11 +2754,11 @@ parse_entry_element (GMarkupParseContext
 
       if (mtime)
         {
           GTime vmtime;
 
-          vmtime = gconf_string_to_gulong (mtime);
+          vmtime = _gconf_string_to_gulong (mtime);
       
           markup_entry_set_mod_time (entry, vmtime);
         }
 
       /* don't use markup_entry_set_schema_name because it would
@@ -3109,22 +3109,22 @@ parse_li_element (GMarkupParseContext  *
     {
       if (value->type == gconf_value_get_list_type (list))
         {
           GSList *slist;
 
-          slist = gconf_value_steal_list (list);
+          slist = _gconf_value_steal_list (list);
           slist = g_slist_append (slist, value);
           gconf_value_set_list_nocopy (list, slist);
           
           value_stack_push (info, value, FALSE); /* FALSE since list owns it */
         }
       else
         {
           gconf_value_free (value);
           set_error (error, context, GCONF_ERROR_PARSE_ERROR,
                      _("<li> has wrong type %s"),
-                     gconf_value_type_to_string (value->type));
+                     _gconf_value_type_to_string (value->type));
         }
     }
   else
     {
       gconf_value_free (value);
@@ -3527,11 +3527,11 @@ text_handler (GMarkupParseContext *conte
         GConfValue *value;
 
         value = value_stack_peek (info);
         g_assert (value->type == GCONF_VALUE_STRING);
 
-        gconf_value_set_string_nocopy (value,
+        _gconf_value_set_string_nocopy (value,
                                        g_strndup (text, text_len));
       }
       break;
     case STATE_LONGDESC:
       {
@@ -3686,18 +3686,18 @@ write_value_element (GConfValue *value,
   /* We are at the "<foo bar="whatever"" stage here,
    * <foo> still missing the closing >
    */
   
   if (fprintf (f, " type=\"%s\"",
-               gconf_value_type_to_string (value->type)) < 0)
+               _gconf_value_type_to_string (value->type)) < 0)
     return FALSE;
   
   switch (value->type)
     {          
     case GCONF_VALUE_LIST:
       if (fprintf (f, " ltype=\"%s\"",
-                   gconf_value_type_to_string (gconf_value_get_list_type (value))) < 0)
+                   _gconf_value_type_to_string (gconf_value_get_list_type (value))) < 0)
         return FALSE;
       break;
       
     case GCONF_VALUE_SCHEMA:
       {
@@ -3708,11 +3708,11 @@ write_value_element (GConfValue *value,
         schema = gconf_value_get_schema (value);
 
         stype = gconf_schema_get_type (schema);
         
         if (fprintf (f, " stype=\"%s\"",
-                     gconf_value_type_to_string (stype)) < 0)
+                     _gconf_value_type_to_string (stype)) < 0)
           return FALSE;
 
         owner = gconf_schema_get_owner (schema);
 
         if (owner)
@@ -3735,11 +3735,11 @@ write_value_element (GConfValue *value,
             GConfValueType list_type = gconf_schema_get_list_type (schema);
 
             if (list_type != GCONF_VALUE_INVALID)
               {
                 if (fprintf (f, " list_type=\"%s\"",
-                             gconf_value_type_to_string (list_type)) < 0)
+                             _gconf_value_type_to_string (list_type)) < 0)
                   return FALSE;
               }
           }
 
         if (stype == GCONF_VALUE_PAIR)
@@ -3751,18 +3751,18 @@ write_value_element (GConfValue *value,
             cdr_type = gconf_schema_get_cdr_type (schema);
 
             if (car_type != GCONF_VALUE_INVALID)
               {
                 if (fprintf (f, " car_type=\"%s\"",
-                             gconf_value_type_to_string (car_type)) < 0)
+                             _gconf_value_type_to_string (car_type)) < 0)
                   return FALSE;
               }
 
             if (cdr_type != GCONF_VALUE_INVALID)
               {
                 if (fprintf (f, " cdr_type=\"%s\"",
-                             gconf_value_type_to_string (cdr_type)) < 0)
+                             _gconf_value_type_to_string (cdr_type)) < 0)
                   return FALSE;
               }
           }
       }
       break;
@@ -3781,11 +3781,11 @@ write_value_element (GConfValue *value,
 
     case GCONF_VALUE_FLOAT:
       {
         char *s;
 
-        s = gconf_double_to_string (gconf_value_get_float (value));
+        s = _gconf_double_to_string (gconf_value_get_float (value));
         if (fprintf (f, " value=\"%s\"", s) < 0)
           {
             g_free (s);
             return FALSE;
           }
Index: backends/xml-entry.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/xml-entry.c,v
retrieving revision 1.32
diff -p -u -5 -r1.32 xml-entry.c
--- backends/xml-entry.c	9 May 2002 15:41:33 -0000	1.32
+++ backends/xml-entry.c	4 May 2006 11:20:55 -0000
@@ -339,11 +339,11 @@ entry_fill_from_node(Entry* e)
       
   tmp = my_xmlGetProp(e->node, "mtime");
 
   if (tmp != NULL)
     {
-      e->mod_time = gconf_string_to_gulong(tmp);
+      e->mod_time = _gconf_string_to_gulong(tmp);
       xmlFree(tmp);
     }
   else
     e->mod_time = 0;
 
@@ -448,32 +448,32 @@ node_set_schema_value(xmlNodePtr node,
   sc = gconf_value_get_schema (value);
 
   /* Set the types */
   if (gconf_schema_get_list_type (sc) != GCONF_VALUE_INVALID)
     {
-      type = gconf_value_type_to_string(gconf_schema_get_list_type (sc));
+      type = _gconf_value_type_to_string(gconf_schema_get_list_type (sc));
       g_assert(type != NULL);
       my_xmlSetProp(node, "list_type", type);
     }
   if (gconf_schema_get_car_type (sc) != GCONF_VALUE_INVALID)
     {
-      type = gconf_value_type_to_string(gconf_schema_get_car_type (sc));
+      type = _gconf_value_type_to_string(gconf_schema_get_car_type (sc));
       g_assert(type != NULL);
       my_xmlSetProp(node, "car_type", type);
     }
   if (gconf_schema_get_cdr_type (sc) != GCONF_VALUE_INVALID)
     {
-      type = gconf_value_type_to_string(gconf_schema_get_cdr_type (sc));
+      type = _gconf_value_type_to_string(gconf_schema_get_cdr_type (sc));
       g_assert(type != NULL);
       my_xmlSetProp(node, "cdr_type", type);
     }
   
   /* unset this in case the node was previously a different type */
   my_xmlSetProp(node, "value", NULL);
 
   /* set the cross-locale attributes */
-  my_xmlSetProp(node, "stype", gconf_value_type_to_string(gconf_schema_get_type (sc)));
+  my_xmlSetProp(node, "stype", _gconf_value_type_to_string(gconf_schema_get_type (sc)));
   my_xmlSetProp(node, "owner", gconf_schema_get_owner (sc));
 
   locale = gconf_schema_get_locale(sc);
 
   gconf_log(GCL_DEBUG, "Setting XML node to schema with locale `%s'",
@@ -515,11 +515,11 @@ node_set_value(xmlNodePtr node, GConfVal
 
   g_return_if_fail(node != NULL);
   g_return_if_fail(value != NULL);
   g_return_if_fail(value->type != GCONF_VALUE_INVALID);
   
-  type = gconf_value_type_to_string(value->type);
+  type = _gconf_value_type_to_string(value->type);
 
   g_assert(type != NULL);
   
   my_xmlSetProp(node, "type", type);
 
@@ -561,11 +561,11 @@ node_set_value(xmlNodePtr node, GConfVal
         GSList* list;
 
         free_childs(node);
 
         my_xmlSetProp(node, "ltype",
-                      gconf_value_type_to_string(gconf_value_get_list_type(value)));
+                      _gconf_value_type_to_string(gconf_value_get_list_type(value)));
         
         /* Add a new child for each node */
         list = gconf_value_get_list(value);
 
         while (list != NULL)
@@ -814,32 +814,32 @@ schema_node_extract_value(xmlNodePtr nod
       xmlFree(owner_str);
     }
   if (stype_str)
     {
       GConfValueType stype;
-      stype = gconf_value_type_from_string(stype_str);
+      stype = _gconf_value_type_from_string(stype_str);
       gconf_schema_set_type(sc, stype);
       xmlFree(stype_str);
     }
   if (list_type_str)
     {
       GConfValueType type;
-      type = gconf_value_type_from_string(list_type_str);
+      type = _gconf_value_type_from_string(list_type_str);
       gconf_schema_set_list_type(sc, type);
       xmlFree(list_type_str);
     }
   if (car_type_str)
     {
       GConfValueType type;
-      type = gconf_value_type_from_string(car_type_str);
+      type = _gconf_value_type_from_string(car_type_str);
       gconf_schema_set_car_type(sc, type);
       xmlFree(car_type_str);
     }
   if (cdr_type_str)
     {
       GConfValueType type;
-      type = gconf_value_type_from_string(cdr_type_str);
+      type = _gconf_value_type_from_string(cdr_type_str);
       gconf_schema_set_cdr_type(sc, type);
       xmlFree(cdr_type_str);
     }  
   
   if (locales != NULL && locales[0])
@@ -946,25 +946,25 @@ node_extract_value(xmlNodePtr node, cons
   
   type_str = my_xmlGetProp(node, "type");
 
   if (type_str == NULL)
     {
-      gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+      _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                       _("No \"type\" attribute for <%s> node"),
                       (node->name ? (char*)node->name : "(nil)"));
       return NULL;
     }
       
-  type = gconf_value_type_from_string(type_str);
+  type = _gconf_value_type_from_string(type_str);
 
   xmlFree(type_str);
   
   switch (type)
     {
     case GCONF_VALUE_INVALID:
       {
-        gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+        _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                         _("A node has unknown \"type\" attribute `%s', ignoring"), type_str);
         return NULL;
       }
       break;
     case GCONF_VALUE_INT:
@@ -975,11 +975,11 @@ node_extract_value(xmlNodePtr node, cons
         
         value_str = my_xmlGetProp(node, "value");
         
         if (value_str == NULL)
           {
-            gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+            _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                             _("No \"value\" attribute for node"));
             return NULL;
           }
             
         value = gconf_value_new_from_string(type, value_str, err);
@@ -1047,21 +1047,21 @@ node_extract_value(xmlNodePtr node, cons
         {
           gchar* s;
           s = my_xmlGetProp(node, "ltype");
           if (s != NULL)
             {
-              list_type = gconf_value_type_from_string(s);
+              list_type = _gconf_value_type_from_string(s);
               xmlFree(s);
             }
         }
 
         switch (list_type)
           {
           case GCONF_VALUE_INVALID:
           case GCONF_VALUE_LIST:
           case GCONF_VALUE_PAIR:
-            gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+            _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                             _("Invalid type (list, pair, or unknown) in a list node"));
               
             return NULL;
           default:
             break;
@@ -1090,12 +1090,12 @@ node_extract_value(xmlNodePtr node, cons
                           }
                       }
                     else if (v->type != list_type)
                       {
                         gconf_log(GCL_WARNING, _("List contains a badly-typed node (%s, should be %s)"),
-                                  gconf_value_type_to_string(v->type),
-                                  gconf_value_type_to_string(list_type));
+                                  _gconf_value_type_to_string(v->type),
+                                  _gconf_value_type_to_string(list_type));
                         gconf_value_free(v);
                         v = NULL;
                       }
                   }
                 else
@@ -1205,23 +1205,23 @@ node_extract_value(xmlNodePtr node, cons
             gconf_log(GCL_WARNING, _("Didn't find car and cdr for XML pair node"));
             if (car)
               {
                 g_assert(cdr == NULL);
                 gconf_value_free(car);
-                gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+                _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                                 _("Missing cdr from pair of values in XML file"));
               }
             else if (cdr)
               {
                 g_assert(car == NULL);
                 gconf_value_free(cdr);
-                gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+                _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                                 _("Missing car from pair of values in XML file"));
               }
             else
               {
-                gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
+                _gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
                                 _("Missing both car and cdr values from pair in XML file"));
               }
 
             return NULL;
           }
Index: backends/xml-cache.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/xml-cache.c,v
retrieving revision 1.24
diff -p -u -5 -r1.24 xml-cache.c
--- backends/xml-cache.c	11 Aug 2004 08:00:37 -0000	1.24
+++ backends/xml-cache.c	4 May 2006 11:20:56 -0000
@@ -280,11 +280,11 @@ cache_sync (Cache    *cache,
   if (!sd.failed && sd.deleted_some)
     goto redo;
   
   if (sd.failed && err && *err == NULL)
     {
-      gconf_set_error (err, GCONF_ERROR_FAILED,
+      _gconf_set_error (err, GCONF_ERROR_FAILED,
 		       _("Failed to sync XML cache contents to disk"));
     }
   
   return !sd.failed;  
 }
@@ -475,11 +475,11 @@ cache_unset_nonexistent (Cache       *ca
   cache_set_nonexistent (cache, key, FALSE);
 
   if (strcmp (key, "/") == 0)
     return;
 
-  parent_key = gconf_key_directory (key);
+  parent_key = _gconf_key_directory (key);
 
   cache_unset_nonexistent (cache, parent_key);
 
   g_free (parent_key);
 }
Index: backends/xml-dir.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/xml-dir.c,v
retrieving revision 1.36
diff -p -u -5 -r1.36 xml-dir.c
--- backends/xml-dir.c	9 Jun 2005 23:53:01 -0000	1.36
+++ backends/xml-dir.c	4 May 2006 11:20:56 -0000
@@ -103,11 +103,11 @@ dir_blank(const gchar* key)
     g_assert(gconf_valid_key(key, NULL));
   }
 #endif
   
   d->key = g_strdup (key);
-  d->parent_key = gconf_key_directory (key);
+  d->parent_key = _gconf_key_directory (key);
   
   d->last_access = time(NULL);
   d->doc = NULL;
 
   d->entry_cache = g_hash_table_new (g_str_hash, g_str_equal);
@@ -164,21 +164,21 @@ dir_load (const gchar* key, const gchar*
     
     if (g_stat(xml_filename, &s) != 0)
       {
         if (errno != ENOENT)
           {
-            gconf_set_error (err, GCONF_ERROR_FAILED,
+            _gconf_set_error (err, GCONF_ERROR_FAILED,
                              _("Could not stat `%s': %s"),
                              xml_filename, g_strerror(errno));
 
           }
         
         notfound = TRUE;
       }
     else if (S_ISDIR(s.st_mode))
       {
-        gconf_set_error (err, GCONF_ERROR_FAILED,
+        _gconf_set_error (err, GCONF_ERROR_FAILED,
                          _("XML filename `%s' is a directory"),
                          xml_filename);
         notfound = TRUE;
       }
 
@@ -412,20 +412,20 @@ dir_sync (Dir      *d,
       gconf_log (GCL_DEBUG, "Deleting useless dir \"%s\"",
                  d->key);
       
       if (g_unlink (d->xml_filename) != 0)
         {
-          gconf_set_error (err, GCONF_ERROR_FAILED, _("Failed to delete \"%s\": %s"),
+          _gconf_set_error (err, GCONF_ERROR_FAILED, _("Failed to delete \"%s\": %s"),
                            d->xml_filename, g_strerror (errno));
           return FALSE;
         }
 
       if (strcmp (d->key, "/") != 0) /* don't delete root dir */
         {
           if (g_rmdir (d->fs_dirname) != 0)
             {
-              gconf_set_error (err, GCONF_ERROR_FAILED, _("Failed to delete \"%s\": %s"),
+              _gconf_set_error (err, GCONF_ERROR_FAILED, _("Failed to delete \"%s\": %s"),
                                d->fs_dirname, g_strerror (errno));
               return FALSE;
             }
         }
 
@@ -452,11 +452,11 @@ dir_sync (Dir      *d,
       outfile = g_fopen (tmp_filename, "w");
 
       if (outfile == NULL)
         {
           /* Try to solve the problem by creating the FS dir */
-          if (!gconf_file_exists(d->fs_dirname))
+          if (!_gconf_file_exists(d->fs_dirname))
             {
               if (create_fs_dir(d->fs_dirname, d->xml_filename,
                                 d->root_dir_len,
                                 d->dir_mode, d->file_mode,
                                 err))
@@ -467,11 +467,11 @@ dir_sync (Dir      *d,
             {
               /* Don't set error if it's already set by some
                * earlier failure.
                */
               if (err && *err == NULL)
-                gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to write file `%s': %s"), 
+                _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to write file `%s': %s"), 
                                 tmp_filename, g_strerror(errno));
               
               retval = FALSE;
               
               goto failed_end_of_sync;
@@ -480,32 +480,32 @@ dir_sync (Dir      *d,
 
 #ifdef HAVE_FCHMOD
       /* Set permissions on the new file */
       if (fchmod (fileno (outfile), d->file_mode) != 0)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED, 
+          _gconf_set_error(err, GCONF_ERROR_FAILED, 
                           _("Failed to set mode on `%s': %s"),
                           tmp_filename, g_strerror(errno));
           
           retval = FALSE;
           goto failed_end_of_sync;
         }
 #endif
 
       if (gconf_xml_doc_dump (outfile, d->doc) < 0)
         {
-          gconf_set_error (err, GCONF_ERROR_FAILED, 
+          _gconf_set_error (err, GCONF_ERROR_FAILED, 
                            _("Failed to write XML data to `%s': %s"),
                            tmp_filename, g_strerror (errno));
           
           retval = FALSE;
           goto failed_end_of_sync;
         }
 
       if (fclose (outfile) < 0)
         {
-          gconf_set_error (err, GCONF_ERROR_FAILED, 
+          _gconf_set_error (err, GCONF_ERROR_FAILED, 
                            _("Failed to close file `%s': %s"),
                            tmp_filename, g_strerror (errno));
           
           retval = FALSE;
           goto failed_end_of_sync;
@@ -515,43 +515,43 @@ dir_sync (Dir      *d,
       
 #ifndef HAVE_FCHMOD
       /* Set permissions on the new file */
       if (chmod (tmp_filename, d->file_mode) != 0)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED, 
+          _gconf_set_error(err, GCONF_ERROR_FAILED, 
                           _("Failed to set mode on `%s': %s"),
                           tmp_filename, g_strerror(errno));
           
           retval = FALSE;
           goto failed_end_of_sync;
         }
 #endif
 
-      old_existed = gconf_file_exists (d->xml_filename);
+      old_existed = _gconf_file_exists (d->xml_filename);
 
       if (old_existed)
         {
           if (g_rename(d->xml_filename, old_filename) < 0)
             {
-              gconf_set_error(err, GCONF_ERROR_FAILED, 
+              _gconf_set_error(err, GCONF_ERROR_FAILED, 
                               _("Failed to rename `%s' to `%s': %s"),
                               d->xml_filename, old_filename, g_strerror(errno));
 
               retval = FALSE;
               goto failed_end_of_sync;
             }
         }
 
       if (g_rename(tmp_filename, d->xml_filename) < 0)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to rename `%s' to `%s': %s"),
+          _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to rename `%s' to `%s': %s"),
                           tmp_filename, d->xml_filename, g_strerror(errno));
 
           /* Put the original file back, so this isn't a total disaster. */
           if (g_rename(old_filename, d->xml_filename) < 0)
             {
-              gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to restore `%s' from `%s': %s"),
+              _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to restore `%s' from `%s': %s"),
                               d->xml_filename, old_filename, g_strerror(errno));
             }
 
           retval = FALSE;
           goto failed_end_of_sync;
@@ -991,11 +991,11 @@ dir_load_doc(Dir* d, GError** err)
         case EACCES:
         case ENOMEM:
         case ENAMETOOLONG:
         default:
           /* These are all fatal errors */
-          gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to stat `%s': %s"),
+          _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to stat `%s': %s"),
                           d->xml_filename, g_strerror(errno));
           return;
           break;
         }
     }
@@ -1217,11 +1217,11 @@ create_fs_dir(const gchar* dir, const gc
 {
   g_return_val_if_fail(xml_filename != NULL, FALSE);
   
   gconf_log(GCL_DEBUG, "Enter create_fs_dir: %s", dir);
   
-  if (gconf_file_test(xml_filename, GCONF_FILE_ISFILE))
+  if (_gconf_file_test(xml_filename, GCONF_FILE_ISFILE))
     {
       gconf_log(GCL_DEBUG, "XML backend file %s already exists", xml_filename);
       return TRUE;
     }
       
@@ -1267,11 +1267,11 @@ create_fs_dir(const gchar* dir, const gc
   
   if (g_mkdir(dir, dir_mode) < 0)
     {
       if (errno != EEXIST)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED,
+          _gconf_set_error(err, GCONF_ERROR_FAILED,
                           _("Could not make directory \"%s\": %s"),
                           (gchar*)dir, g_strerror(errno));
           return FALSE;
         }
     }
@@ -1284,19 +1284,19 @@ create_fs_dir(const gchar* dir, const gc
 
       gconf_log(GCL_DEBUG, "Creating XML file %s", xml_filename);
       
       if (fd < 0)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to create file `%s': %s"),
+          _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to create file `%s': %s"),
                           xml_filename, g_strerror(errno));
           
           return FALSE;
         }
       
       if (close(fd) < 0)
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to close file `%s': %s"),
+          _gconf_set_error(err, GCONF_ERROR_FAILED, _("Failed to close file `%s': %s"),
                           xml_filename, g_strerror(errno));
           
           return FALSE;
         }
     }
Index: backends/markup-backend.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/markup-backend.c,v
retrieving revision 1.17
diff -p -u -5 -r1.17 markup-backend.c
--- backends/markup-backend.c	3 Jan 2006 17:05:28 -0000	1.17
+++ backends/markup-backend.c	4 May 2006 11:20:56 -0000
@@ -217,15 +217,15 @@ get_dir_from_address (const char *addres
                       GError    **err)
 {
   char *root_dir;
   int len;
   
-  root_dir = gconf_address_resource (address);
+  root_dir = _gconf_address_resource (address);
 
   if (root_dir == NULL)
     {
-      gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
+      _gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
                        _("Couldn't find the XML root directory in the address `%s'"),
                        address);
       return NULL;
     }
 
@@ -278,21 +278,21 @@ resolve_address (const char *address,
       file_mode = dir_mode & (~0111);
     }
   else if (g_mkdir (root_dir, dir_mode) < 0)
     {
       /* Error out even on EEXIST - shouldn't happen anyway */
-      gconf_set_error (err, GCONF_ERROR_FAILED,
+      _gconf_set_error (err, GCONF_ERROR_FAILED,
 		       _("Could not make directory `%s': %s"),
 		       root_dir, g_strerror (errno));
       g_free (root_dir);
       return NULL;
     }
 
   force_readonly = FALSE;
   merged = FALSE;
   
-  address_flags = gconf_address_flags (address);  
+  address_flags = _gconf_address_flags (address);  
   if (address_flags)
     {
       iter = address_flags;
       while (*iter)
         {
@@ -343,18 +343,18 @@ resolve_address (const char *address,
 
     /* We only do locking if it's writable,
      * and if not using local locks,
      * which is sort of broken but close enough
      */
-    if (writable && !gconf_use_local_locks ())
+    if (writable && !_gconf_use_local_locks ())
       {
         gchar* lockdir;
 
         /* use same lockfile name as XML backend, for safety */
         lockdir = get_lock_dir_from_root_dir (root_dir);
         
-        lock = gconf_get_lock (lockdir, err);
+        lock = _gconf_get_lock (lockdir, err);
 
         if (lock != NULL)
           gconf_log (GCL_DEBUG, "Acquired lock directory `%s'", lockdir);
         
         g_free (lockdir);
@@ -385,11 +385,11 @@ resolve_address (const char *address,
   }
 
   if (!(flags & GCONF_SOURCE_ALL_READABLE) &&
       !(flags & GCONF_SOURCE_ALL_WRITEABLE))
     {
-      gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
+      _gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
                        _("Can't read from or write to the XML root directory in the address \"%s\""),
                        address);
       g_free (root_dir);
       return NULL;
     }
@@ -419,11 +419,11 @@ tree_lookup_entry (MarkupTree *tree,
 {
   char* parent;
   MarkupDir *dir;
   GError* error = NULL;
 
-  parent = gconf_key_directory (key);
+  parent = _gconf_key_directory (key);
   
   g_assert (parent != NULL);
 
   if (create_if_not_found)
     dir = markup_tree_ensure_dir (tree, parent, &error);
@@ -809,11 +809,11 @@ blow_away_locks (const char *address)
   const char *dent;
 
   /* /tmp locks should never be stuck, and possible security issue to
    * blow them away
    */
-  if (gconf_use_local_locks ())
+  if (_gconf_use_local_locks ())
     return;
   
   root_dir = get_dir_from_address (address, NULL);
   if (root_dir == NULL)
     return;
@@ -931,11 +931,11 @@ ms_destroy (MarkupSource* ms)
   g_return_if_fail (ms != NULL);
 
   /* do this first in case we're in a "fast cleanup just before exit"
    * situation
    */
-  if (ms->lock != NULL && !gconf_release_lock (ms->lock, &error))
+  if (ms->lock != NULL && !_gconf_release_lock (ms->lock, &error))
     {
       gconf_log (GCL_ERR, _("Failed to give up lock on XML directory \"%s\": %s"),
                  ms->root_dir, error->message);
       g_error_free(error);
       error = NULL;
Index: backends/xml-backend.c
===================================================================
RCS file: /export/cvs/head/gconf/backends/xml-backend.c,v
retrieving revision 1.91
diff -p -u -5 -r1.91 xml-backend.c
--- backends/xml-backend.c	9 Jun 2005 23:53:01 -0000	1.91
+++ backends/xml-backend.c	4 May 2006 11:20:56 -0000
@@ -278,15 +278,15 @@ get_dir_from_address (const char *addres
                       GError    **err)
 {
   char *root_dir;
   int len;
   
-  root_dir = gconf_address_resource (address);
+  root_dir = _gconf_address_resource (address);
 
   if (root_dir == NULL)
     {
-      gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
+      _gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS,
                        _("Couldn't find the XML root directory in the address `%s'"),
                        address);
       return NULL;
     }
 
@@ -337,20 +337,20 @@ resolve_address (const gchar* address, G
       file_mode = dir_mode & (~0111); 
     }
   else if (g_mkdir (root_dir, dir_mode) < 0)
     {
       /* Error out even on EEXIST - shouldn't happen anyway */
-      gconf_set_error (err, GCONF_ERROR_FAILED,
+      _gconf_set_error (err, GCONF_ERROR_FAILED,
 		       _("Could not make directory `%s': %s"),
 		      (gchar *)root_dir, g_strerror (errno));
       g_free (root_dir);
       return NULL;
     }
 
   force_readonly = FALSE;
   
-  address_flags = gconf_address_flags (address);  
+  address_flags = _gconf_address_flags (address);  
   if (address_flags)
     {
       iter = address_flags;
       while (*iter)
         {
@@ -396,17 +396,17 @@ resolve_address (const gchar* address, G
 
     /* We only do locking if it's writable,
      * and if not using local locks,
      * which is sort of broken but close enough
      */
-    if (writable && !gconf_use_local_locks ())
+    if (writable && !_gconf_use_local_locks ())
       {
         gchar* lockdir;
 
         lockdir = get_lock_dir_from_root_dir (root_dir);
         
-        lock = gconf_get_lock(lockdir, err);
+        lock = _gconf_get_lock(lockdir, err);
 
         if (lock != NULL)
           gconf_log(GCL_DEBUG, "Acquired lock directory `%s'", lockdir);
         
         g_free(lockdir);
@@ -437,11 +437,11 @@ resolve_address (const gchar* address, G
   }
 
   if (!(flags & GCONF_SOURCE_ALL_READABLE) &&
       !(flags & GCONF_SOURCE_ALL_WRITEABLE))
     {
-      gconf_set_error(err, GCONF_ERROR_BAD_ADDRESS, _("Can't read from or write to the XML root directory in the address \"%s\""), address);
+      _gconf_set_error(err, GCONF_ERROR_BAD_ADDRESS, _("Can't read from or write to the XML root directory in the address \"%s\""), address);
       g_free(root_dir);
       return NULL;
     }  
   
   /* Create the new source */
@@ -471,11 +471,11 @@ query_value (GConfSource* source,
   XMLSource* xs = (XMLSource*)source;
   gchar* parent;
   Dir* dir;
   GError* error = NULL;
 
-  parent = gconf_key_directory(key);
+  parent = _gconf_key_directory(key);
   
   g_assert(parent != NULL);
   
   dir = cache_lookup(xs->cache, parent, FALSE, &error);
 
@@ -522,11 +522,11 @@ query_metainfo  (GConfSource* source, co
 {
   XMLSource* xs = (XMLSource*)source;
   gchar* parent;
   Dir* dir;
 
-  parent = gconf_key_directory(key);
+  parent = _gconf_key_directory(key);
 
   if (parent != NULL)
     {
       dir = cache_lookup(xs->cache, parent, FALSE, err);
       g_free(parent);
@@ -555,11 +555,11 @@ set_value (GConfSource* source, const gc
   gchar* parent;
   
   g_return_if_fail(value != NULL);
   g_return_if_fail(source != NULL);
   
-  parent = gconf_key_directory(key);
+  parent = _gconf_key_directory(key);
   
   g_assert(parent != NULL);
   
   dir = cache_lookup(xs->cache, parent, TRUE, err);
   
@@ -640,11 +640,11 @@ unset_value     (GConfSource* source,
   Dir* dir;
   gchar* parent;
 
   gconf_log(GCL_DEBUG, "XML backend: unset value `%s'", key);
   
-  parent = gconf_key_directory(key);
+  parent = _gconf_key_directory(key);
   
   dir = cache_lookup(xs->cache, parent, FALSE, err);
 
   g_free(parent);
   
@@ -695,11 +695,11 @@ set_schema (GConfSource *source,
   gchar* parent;
 
   g_return_if_fail (source != NULL);
   g_return_if_fail (key != NULL);
 
-  parent = gconf_key_directory (key);
+  parent = _gconf_key_directory (key);
   
   g_assert (parent != NULL);
   
   dir = cache_lookup (xs->cache, parent, TRUE, err);
   
@@ -751,11 +751,11 @@ blow_away_locks (const char *address)
   const char *dent;
 
   /* /tmp locks should never be stuck, and possible security issue to
    * blow them away
    */
-  if (gconf_use_local_locks ())
+  if (_gconf_use_local_locks ())
     return;
   
   root_dir = get_dir_from_address (address, NULL);
   if (root_dir == NULL)
     return;
@@ -873,11 +873,11 @@ xs_destroy   (XMLSource* xs)
   
   g_return_if_fail(xs != NULL);
 
   /* do this first in case we're in a "fast cleanup just before exit"
      situation */
-  if (xs->lock != NULL && !gconf_release_lock(xs->lock, &error))
+  if (xs->lock != NULL && !_gconf_release_lock(xs->lock, &error))
     {
       gconf_log (GCL_ERR, _("Failed to give up lock on XML directory \"%s\": %s"),
                  xs->root_dir, error->message);
       g_error_free(error);
       error = NULL;
Index: gconf/gconf-schema.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-schema.c,v
retrieving revision 1.15
diff -p -u -5 -r1.15 gconf-schema.c
--- gconf/gconf-schema.c	17 Feb 2006 16:12:37 -0000	1.15
+++ gconf/gconf-schema.c	4 May 2006 11:20:58 -0000
@@ -201,11 +201,11 @@ gconf_schema_set_default_value_nocopy (G
 
   REAL_SCHEMA (sc)->default_value = val;
 }
 
 gboolean
-gconf_schema_validate (const GConfSchema *sc,
+_gconf_schema_validate (const GConfSchema *sc,
                        GError           **err)
 {
   GConfRealSchema *real;
 
   real = REAL_SCHEMA (sc);
@@ -335,11 +335,11 @@ gconf_schema_get_default_value (const GC
 
   return REAL_SCHEMA (schema)->default_value;
 }
 
 GConfValue*
-gconf_schema_steal_default_value (GConfSchema *schema)
+_gconf_schema_steal_default_value (GConfSchema *schema)
 {
   GConfValue *val;
   
   g_return_val_if_fail (schema != NULL, NULL);
 
Index: gconf/gconf-value.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-value.c,v
retrieving revision 1.45
diff -p -u -5 -r1.45 gconf-value.c
--- gconf/gconf-value.c	17 Feb 2006 16:20:16 -0000	1.45
+++ gconf/gconf-value.c	4 May 2006 11:20:58 -0000
@@ -103,21 +103,21 @@ gconf_value_new_from_string(GConfValueTy
         result = strtol(value_str, &endptr, 10);
 
         if (endptr == value_str)
           {
             if (err)
-              *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+              *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                                       _("Didn't understand `%s' (expected integer)"),
                                       value_str);
             
             gconf_value_free(value);
             value = NULL;
           }
         else if (errno == ERANGE)
           {
             if (err)
-              *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+              *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                                       _("Integer `%s' is too large or small"),
                                       value_str);
             gconf_value_free(value);
             value = NULL;
           }
@@ -127,18 +127,18 @@ gconf_value_new_from_string(GConfValueTy
       break;
     case GCONF_VALUE_FLOAT:
       {
         double num;
 
-        if (gconf_string_to_double(value_str, &num))
+        if (_gconf_string_to_double(value_str, &num))
           {
             gconf_value_set_float(value, num);
           }
         else
           {
             if (err)
-              *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+              *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                                       _("Didn't understand `%s' (expected real number)"),
                                      value_str);
             
             gconf_value_free(value);
             value = NULL;
@@ -178,11 +178,11 @@ gconf_value_new_from_string(GConfValueTy
           gconf_value_set_bool(value, FALSE);
           break;
           
         default:
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+            *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                                    _("Didn't understand `%s' (expected true or false)"),
                                    value_str);
           
           gconf_value_free(value);
           value = NULL;
@@ -230,11 +230,11 @@ escape_string(const char *str, const cha
 
   return ret;
 }
 
 GConfValue*
-gconf_value_new_list_from_string(GConfValueType list_type,
+_gconf_value_new_list_from_string(GConfValueType list_type,
                                   const gchar* str,
 				  GError** err)
 {
   int i, len;
   gboolean escaped, pending_chars;
@@ -254,11 +254,11 @@ gconf_value_new_list_from_string(GConfVa
     }
   
   if (str[0] != '[')
     {
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (list must start with a '[')"),
 			       str);
       return NULL;
     }
 
@@ -267,11 +267,11 @@ gconf_value_new_list_from_string(GConfVa
   /* Note: by now len is sure to be 1 or larger, so len-1 will never be
    * negative */
   if (str[len-1] != ']')
     {
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (list must end with a ']')"),
 			       str);
       return NULL;
     }
 
@@ -318,11 +318,11 @@ gconf_value_new_list_from_string(GConfVa
 	      g_slist_free(list);
 
 	      g_string_free(string, TRUE);
 
 	      if (err)
-		*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+		*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 				       _("Didn't understand `%s' (extra unescaped ']' found inside list)"),
 				       str);
 	      return NULL;
 	    }
 	  pending_chars = FALSE;
@@ -349,11 +349,11 @@ gconf_value_new_list_from_string(GConfVa
       g_slist_free(list);
 
       g_string_free(string, TRUE);
 
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (extra trailing characters)"),
 			       str);
       return NULL;
     }
 
@@ -367,11 +367,11 @@ gconf_value_new_list_from_string(GConfVa
 
   return value;
 }
 
 GConfValue*
-gconf_value_new_pair_from_string(GConfValueType car_type,
+_gconf_value_new_pair_from_string(GConfValueType car_type,
                                   GConfValueType cdr_type,
                                   const gchar* str,
 				  GError** err)
 {
   int i, len;
@@ -396,11 +396,11 @@ gconf_value_new_pair_from_string(GConfVa
     }
   
   if (str[0] != '(')
     {
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (pair must start with a '(')"),
 			       str);
       return NULL;
     }
 
@@ -409,11 +409,11 @@ gconf_value_new_pair_from_string(GConfVa
   /* Note: by now len is sure to be 1 or larger, so len-1 will never be
    * negative */
   if (str[len-1] != ')')
     {
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (pair must end with a ')')"),
 			       str);
       return NULL;
     }
 
@@ -439,11 +439,11 @@ gconf_value_new_pair_from_string(GConfVa
 	        gconf_value_free(cdr);
 
 	      g_string_free(string, TRUE);
 
 	      if (err)
-		*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+		*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 				       _("Didn't understand `%s' (wrong number of elements)"),
 				       str);
 	      return NULL;
 	    }
 
@@ -479,11 +479,11 @@ gconf_value_new_pair_from_string(GConfVa
 	        gconf_value_free(cdr);
 
 	      g_string_free(string, TRUE);
 
 	      if (err)
-		*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+		*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 				       _("Didn't understand `%s' (extra unescaped ')' found inside pair)"),
 				       str);
 	      return NULL;
 	    }
 	  pending_chars = FALSE;
@@ -510,11 +510,11 @@ gconf_value_new_pair_from_string(GConfVa
 	gconf_value_free(car);
       if (cdr)
 	gconf_value_free(cdr);
 
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (extra trailing characters)"),
 			       str);
       return NULL;
     }
 
@@ -525,11 +525,11 @@ gconf_value_new_pair_from_string(GConfVa
 	gconf_value_free(car);
       if (cdr)
 	gconf_value_free(cdr);
 
       if (err)
-	*err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+	*err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
 			       _("Didn't understand `%s' (wrong number of elements)"),
 			       str);
       return NULL;
     }
 
@@ -553,11 +553,11 @@ gconf_value_to_string(const GConfValue* 
     {
     case GCONF_VALUE_INT:
       retval = g_strdup_printf("%d", gconf_value_get_int(value));
       break;
     case GCONF_VALUE_FLOAT:
-      retval = gconf_double_to_string(gconf_value_get_float(value));
+      retval = _gconf_double_to_string(gconf_value_get_float(value));
       break;
     case GCONF_VALUE_STRING:
       retval = g_strdup(gconf_value_get_string(value));
       break;
     case GCONF_VALUE_BOOL:
@@ -669,14 +669,14 @@ gconf_value_to_string(const GConfValue* 
         const gchar* list_type;
         const gchar* car_type;
         const gchar* cdr_type;
         
         locale = gconf_schema_get_locale(gconf_value_get_schema(value));
-        type = gconf_value_type_to_string(gconf_schema_get_type(gconf_value_get_schema(value)));
-        list_type = gconf_value_type_to_string(gconf_schema_get_list_type(gconf_value_get_schema(value)));
-        car_type = gconf_value_type_to_string(gconf_schema_get_car_type(gconf_value_get_schema(value)));
-        cdr_type = gconf_value_type_to_string(gconf_schema_get_cdr_type(gconf_value_get_schema(value)));
+        type = _gconf_value_type_to_string(gconf_schema_get_type(gconf_value_get_schema(value)));
+        list_type = _gconf_value_type_to_string(gconf_schema_get_list_type(gconf_value_get_schema(value)));
+        car_type = _gconf_value_type_to_string(gconf_schema_get_car_type(gconf_value_get_schema(value)));
+        cdr_type = _gconf_value_type_to_string(gconf_schema_get_cdr_type(gconf_value_get_schema(value)));
         
         retval = g_strdup_printf("Schema (type: `%s' list_type: '%s' "
 				 "car_type: '%s' cdr_type: '%s' locale: `%s')",
                                  type, list_type, car_type, cdr_type,
 				 locale ? locale : "(null)");
@@ -837,11 +837,11 @@ gconf_value_get_string (const GConfValue
   
   return REAL_VALUE (value)->d.string_data;
 }
 
 char*
-gconf_value_steal_string (GConfValue *value)
+_gconf_value_steal_string (GConfValue *value)
 {
   char *string;
   GConfRealValue *real;
   
   g_return_val_if_fail (value != NULL, NULL);
@@ -890,11 +890,11 @@ gconf_value_get_list (const GConfValue *
 
   return REAL_VALUE (value)->d.list_data.list;
 }
 
 GSList*
-gconf_value_steal_list (GConfValue *value)
+_gconf_value_steal_list (GConfValue *value)
 {
   GSList *list;
   GConfRealValue *real;
   
   g_return_val_if_fail (value != NULL, NULL);
@@ -943,11 +943,11 @@ gconf_value_get_schema (const GConfValue
   
   return REAL_VALUE (value)->d.schema_data;
 }
 
 GConfSchema*
-gconf_value_steal_schema (GConfValue *value)
+_gconf_value_steal_schema (GConfValue *value)
 {
   GConfSchema *schema;
   GConfRealValue *real;
   
   g_return_val_if_fail (value != NULL, NULL);
@@ -971,16 +971,16 @@ gconf_value_set_int(GConfValue* value, g
 }
 
 void        
 gconf_value_set_string(GConfValue* value, const gchar* the_str)
 {  
-  gconf_value_set_string_nocopy (value,
+  _gconf_value_set_string_nocopy (value,
                                  g_strdup (the_str));
 }
 
 void
-gconf_value_set_string_nocopy (GConfValue *value,
+_gconf_value_set_string_nocopy (GConfValue *value,
                                char       *str)
 {
   GConfRealValue *real;
 
   g_return_if_fail(value != NULL);
@@ -1645,11 +1645,11 @@ gconf_entry_set_is_writable (GConfEntry 
   REAL_ENTRY (entry)->is_writable = is_writable;
 }
 
 
 gboolean
-gconf_value_validate (const GConfValue *value,
+_gconf_value_validate (const GConfValue *value,
                       GError          **err)
 {
   GConfRealValue *real;
 
   g_return_val_if_fail (value != NULL, FALSE);
@@ -1669,11 +1669,11 @@ gconf_value_validate (const GConfValue *
         }
       break;
 
     case GCONF_VALUE_SCHEMA:
       if (real->d.schema_data)
-        return gconf_schema_validate (real->d.schema_data,
+        return _gconf_schema_validate (real->d.schema_data,
                                       err);
       break;
 
     default:
       break;
Index: gconf/gconf-changeset.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-changeset.c,v
retrieving revision 1.16
diff -p -u -5 -r1.16 gconf-changeset.c
--- gconf/gconf-changeset.c	4 Nov 2003 22:42:05 -0000	1.16
+++ gconf/gconf-changeset.c	4 May 2006 11:20:59 -0000
@@ -370,11 +370,11 @@ gconf_change_set_set_list    (GConfChang
   g_return_if_fail(key != NULL);
   g_return_if_fail(list_type != GCONF_VALUE_INVALID);
   g_return_if_fail(list_type != GCONF_VALUE_LIST);
   g_return_if_fail(list_type != GCONF_VALUE_PAIR);
   
-  value_list = gconf_value_list_from_primitive_list (list_type, list, NULL);
+  value_list = _gconf_value_list_from_primitive_list (list_type, list, NULL);
   
   gconf_change_set_set_nocopy(cs, key, value_list);
 }
 
 
@@ -395,11 +395,11 @@ gconf_change_set_set_pair    (GConfChang
   g_return_if_fail(cdr_type != GCONF_VALUE_LIST);
   g_return_if_fail(cdr_type != GCONF_VALUE_PAIR);
   g_return_if_fail(address_of_car != NULL);
   g_return_if_fail(address_of_cdr != NULL);
 
-  pair = gconf_value_pair_from_primitive_pair (car_type, cdr_type,
+  pair = _gconf_value_pair_from_primitive_pair (car_type, cdr_type,
                                                address_of_car, address_of_cdr,
                                                NULL);
   
   gconf_change_set_set_nocopy(cs, key, pair);
 }
Index: gconf/gconf-internals.h
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-internals.h,v
retrieving revision 1.82
diff -p -u -5 -r1.82 gconf-internals.h
--- gconf/gconf-internals.h	9 Dec 2005 10:01:48 -0000	1.82
+++ gconf/gconf-internals.h	4 May 2006 11:20:59 -0000
@@ -85,61 +85,61 @@ const char *_gconf_win32_get_home_dir (v
 
 #endif
 
 #define GCONF_DATABASE_LIST_DELIM ';'
 
-gchar*       gconf_key_directory  (const gchar* key);
+gchar*       _gconf_key_directory  (const gchar* key);
 const gchar* gconf_key_key        (const gchar* key);
 
 /* These file tests are in libgnome, I cut-and-pasted them */
 enum {
   GCONF_FILE_EXISTS=(1<<0)|(1<<1)|(1<<2), /*any type of file*/
   GCONF_FILE_ISFILE=1<<0,
   GCONF_FILE_ISLINK=1<<1,
   GCONF_FILE_ISDIR=1<<2
 };
 
-gboolean gconf_file_test   (const gchar* filename, int test);
-gboolean gconf_file_exists (const gchar* filename);
+gboolean _gconf_file_test   (const gchar* filename, int test);
+gboolean _gconf_file_exists (const gchar* filename);
 
-GConfValue*  gconf_value_from_corba_value            (const ConfigValue *value);
-ConfigValue* gconf_corba_value_from_gconf_value      (const GConfValue  *value);
-void         gconf_fill_corba_value_from_gconf_value (const GConfValue  *value,
+GConfValue*  _gconf_value_from_corba_value            (const ConfigValue *value);
+ConfigValue* _gconf_corba_value_from_gconf_value      (const GConfValue  *value);
+void         _gconf_fill_corba_value_from_gconf_value (const GConfValue  *value,
                                                       ConfigValue       *dest);
-ConfigValue* gconf_invalid_corba_value               (void);
+ConfigValue* _gconf_invalid_corba_value               (void);
 
-void          gconf_fill_corba_schema_from_gconf_schema (const GConfSchema  *sc,
+void          _gconf_fill_corba_schema_from_gconf_schema (const GConfSchema  *sc,
                                                          ConfigSchema       *dest);
-ConfigSchema* gconf_corba_schema_from_gconf_schema      (const GConfSchema  *sc);
-GConfSchema*  gconf_schema_from_corba_schema            (const ConfigSchema *cs);
+ConfigSchema* _gconf_corba_schema_from_gconf_schema      (const GConfSchema  *sc);
+GConfSchema*  _gconf_schema_from_corba_schema            (const ConfigSchema *cs);
 
-gchar* gconf_object_to_string (CORBA_Object obj,
+gchar* _gconf_object_to_string (CORBA_Object obj,
                                GError **err);
 
-char   *gconf_address_list_get_persistent_name (GSList     *addresses);
-GSList *gconf_persistent_name_get_address_list (const char *persistent_name);
-void    gconf_address_list_free                (GSList     *addresses);
+char   *_gconf_address_list_get_persistent_name (GSList     *addresses);
+GSList *_gconf_persistent_name_get_address_list (const char *persistent_name);
+void    _gconf_address_list_free                (GSList     *addresses);
 
-const gchar*   gconf_value_type_to_string   (GConfValueType  type);
-GConfValueType gconf_value_type_from_string (const gchar    *str);
+const gchar*   _gconf_value_type_to_string   (GConfValueType  type);
+GConfValueType _gconf_value_type_from_string (const gchar    *str);
 
 
-GSList*       gconf_load_source_path (const gchar* filename, GError** err);
+GSList*       _gconf_load_source_path (const gchar* filename, GError** err);
 
 /* shouldn't be used in applications (although implemented in gconf.c) */
 
-void     gconf_shutdown_daemon (GError **err);
-gboolean gconf_ping_daemon     (void);
-gboolean gconf_spawn_daemon    (GError **err);
-int      gconf_orb_release     (void);
+void     _gconf_shutdown_daemon (GError **err);
+gboolean _gconf_ping_daemon     (void);
+gboolean _gconf_spawn_daemon    (GError **err);
+int      _gconf_orb_release     (void);
 
 /* Returns 0 on failure (or if the string is "0" of course) */
-gulong       gconf_string_to_gulong (const gchar *str);
-gboolean     gconf_string_to_double (const gchar *str,
+gulong       _gconf_string_to_gulong (const gchar *str);
+gboolean     _gconf_string_to_double (const gchar *str,
                                      gdouble     *val);
-gchar*       gconf_double_to_string (gdouble      val);
-const gchar* gconf_current_locale   (void);
+gchar*       _gconf_double_to_string (gdouble      val);
+const gchar* _gconf_current_locale   (void);
 
 
 /* Log wrapper; we might want to not use syslog someday */
 typedef enum {
   GCL_EMERG,
@@ -155,141 +155,141 @@ typedef enum {
 void          gconf_log      (GConfLogPriority pri, const gchar* format, ...) G_GNUC_PRINTF (2, 3);
 
 extern gboolean gconf_log_debug_messages;
 
 /* return FALSE and set error if the key is bad */
-gboolean      gconf_key_check(const gchar* key, GError** err);
+gboolean      _gconf_key_check(const gchar* key, GError** err);
 
 /*
  * If these were public they'd be in gconf-value.h
  */
 
 /* for the complicated types */
-GConfValue* gconf_value_new_list_from_string (GConfValueType list_type,
+GConfValue* _gconf_value_new_list_from_string (GConfValueType list_type,
                                               const gchar* str,
 					      GError** err);
-GConfValue* gconf_value_new_pair_from_string (GConfValueType car_type,
+GConfValue* _gconf_value_new_pair_from_string (GConfValueType car_type,
                                               GConfValueType cdr_type,
                                               const gchar* str,
 					      GError** err);
 
-GSList*      gconf_value_steal_list   (GConfValue *value);
-GConfSchema* gconf_value_steal_schema (GConfValue *value);
-char*        gconf_value_steal_string (GConfValue *value);
+GSList*      _gconf_value_steal_list   (GConfValue *value);
+GConfSchema* _gconf_value_steal_schema (GConfValue *value);
+char*        _gconf_value_steal_string (GConfValue *value);
 
 /* These are a hack to encode values into strings and ship them over CORBA,
  * necessary for obscure reasons (ORBit doesn't like recursive datatypes yet)
  */
 
 /* string quoting is only public for the benefit of the test suite */
 
-gchar* gconf_quote_string           (const gchar  *str);
-gchar* gconf_unquote_string         (const gchar  *str,
+gchar* _gconf_quote_string           (const gchar  *str);
+gchar* _gconf_unquote_string         (const gchar  *str,
                                      const gchar **end,
                                      GError      **err);
-void   gconf_unquote_string_inplace (gchar        *str,
+void   _gconf_unquote_string_inplace (gchar        *str,
                                      gchar       **end,
                                      GError      **err);
 
-GConfValue* gconf_value_decode (const gchar *encoded);
-gchar*      gconf_value_encode (GConfValue  *val);
+GConfValue* _gconf_value_decode (const gchar *encoded);
+gchar*      _gconf_value_encode (GConfValue  *val);
 
 /*
  * List/pair conversion stuff
  */
 
-GConfValue* gconf_value_list_from_primitive_list (GConfValueType  list_type,
+GConfValue* _gconf_value_list_from_primitive_list (GConfValueType  list_type,
                                                   GSList         *list,
                                                   GError        **err);
-GConfValue* gconf_value_pair_from_primitive_pair (GConfValueType  car_type,
+GConfValue* _gconf_value_pair_from_primitive_pair (GConfValueType  car_type,
                                                   GConfValueType  cdr_type,
                                                   gconstpointer   address_of_car,
                                                   gconstpointer   address_of_cdr,
                                                   GError        **err);
 
-GSList*  gconf_value_list_to_primitive_list_destructive (GConfValue      *val,
+GSList*  _gconf_value_list_to_primitive_list_destructive (GConfValue      *val,
                                                          GConfValueType   list_type,
                                                          GError         **err);
-gboolean gconf_value_pair_to_primitive_pair_destructive (GConfValue      *val,
+gboolean _gconf_value_pair_to_primitive_pair_destructive (GConfValue      *val,
                                                          GConfValueType   car_type,
                                                          GConfValueType   cdr_type,
                                                          gpointer         car_retloc,
                                                          gpointer         cdr_retloc,
                                                          GError         **err);
 
 
-void         gconf_set_daemon_mode (gboolean     setting);
-gboolean     gconf_in_daemon_mode  (void);
-void         gconf_set_daemon_ior  (const gchar *ior);
-const gchar* gconf_get_daemon_ior  (void);
+void         _gconf_set_daemon_mode (gboolean     setting);
+gboolean     _gconf_in_daemon_mode  (void);
+void         _gconf_set_daemon_ior  (const gchar *ior);
+const gchar* _gconf_get_daemon_ior  (void);
 
 /* Returns TRUE if there was an error, frees exception, sets err */
 gboolean gconf_handle_oaf_exception (CORBA_Environment* ev, GError** err);
 
 void gconf_nanosleep (gulong useconds);
 
 typedef struct _GConfLock GConfLock;
 
-GConfLock* gconf_get_lock     (const gchar  *lock_directory,
+GConfLock* _gconf_get_lock     (const gchar  *lock_directory,
                                GError      **err);
-gboolean   gconf_release_lock (GConfLock    *lock,
+gboolean   _gconf_release_lock (GConfLock    *lock,
                                GError      **err);
-GConfLock* gconf_get_lock_or_current_holder (const gchar  *lock_directory,
+GConfLock* _gconf_get_lock_or_current_holder (const gchar  *lock_directory,
                                              ConfigServer *current_server,
                                              GError      **err);
-ConfigServer gconf_get_current_lock_holder  (const gchar *lock_directory,
+ConfigServer _gconf_get_current_lock_holder  (const gchar *lock_directory,
                                              GString     *failure_log);
 
-void gconf_daemon_blow_away_locks (void);
+void _gconf_daemon_blow_away_locks (void);
 
-GError*  gconf_error_new  (GConfError en,
+GError*  _gconf_error_new  (GConfError en,
                            const gchar* format, ...) G_GNUC_PRINTF (2, 3);
 
-void     gconf_set_error  (GError** err,
+void     _gconf_set_error  (GError** err,
                            GConfError en,
                            const gchar* format, ...) G_GNUC_PRINTF (3, 4);
 
 /* merge two errors into a single message */
-GError*  gconf_compose_errors (GError* err1, GError* err2);
+GError*  _gconf_compose_errors (GError* err1, GError* err2);
 
-CORBA_ORB gconf_orb_get (void);
+CORBA_ORB _gconf_orb_get (void);
 
-ConfigServer gconf_activate_server (gboolean  start_if_not_found,
+ConfigServer _gconf_activate_server (gboolean  start_if_not_found,
                                     GError  **error);
 
-char*     gconf_get_lock_dir (void);
-char*     gconf_get_daemon_dir (void);
+char*     _gconf_get_lock_dir (void);
+char*     _gconf_get_daemon_dir (void);
 
-gboolean gconf_schema_validate (const GConfSchema  *sc,
+gboolean _gconf_schema_validate (const GConfSchema  *sc,
                                 GError            **err);
-gboolean gconf_value_validate  (const GConfValue   *value,
+gboolean _gconf_value_validate  (const GConfValue   *value,
                                 GError            **err);
 
 
-void gconf_engine_set_owner        (GConfEngine *engine,
+void _gconf_engine_set_owner        (GConfEngine *engine,
                                     gpointer     client);
-void gconf_engine_push_owner_usage (GConfEngine *engine,
+void _gconf_engine_push_owner_usage (GConfEngine *engine,
                                     gpointer     client);
-void gconf_engine_pop_owner_usage  (GConfEngine *engine,
+void _gconf_engine_pop_owner_usage  (GConfEngine *engine,
                                     gpointer     client);
 
-gboolean gconf_engine_recursive_unset (GConfEngine      *engine,
+gboolean _gconf_engine_recursive_unset (GConfEngine      *engine,
                                        const char       *key,
                                        GConfUnsetFlags   flags,
                                        GError          **err);
 
-gboolean gconf_CORBA_Object_equal (gconstpointer a,
+gboolean _gconf_CORBA_Object_equal (gconstpointer a,
                                    gconstpointer b);
-guint    gconf_CORBA_Object_hash  (gconstpointer key);
+guint    _gconf_CORBA_Object_hash  (gconstpointer key);
 
-GConfValue* gconf_schema_steal_default_value (GConfSchema *schema);
+GConfValue* _gconf_schema_steal_default_value (GConfSchema *schema);
 
-void gconf_value_set_string_nocopy (GConfValue *value,
+void _gconf_value_set_string_nocopy (GConfValue *value,
                                     char       *str);
 
 void _gconf_init_i18n (void);
 
-gboolean gconf_use_local_locks (void);
+gboolean _gconf_use_local_locks (void);
 
 #endif /* GCONF_ENABLE_INTERNALS */
 
 #endif /* GCONF_GCONF_INTERNALS_H */
Index: gconf/gconf-locale.h
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-locale.h,v
retrieving revision 1.4
diff -p -u -5 -r1.4 gconf-locale.h
--- gconf/gconf-locale.h	11 Sep 2000 02:11:09 -0000	1.4
+++ gconf/gconf-locale.h	4 May 2006 11:20:59 -0000
@@ -29,13 +29,13 @@ extern "C" {
 /*
  * This thing caches the fallback list for a locale string.
  */
 typedef struct _GConfLocaleCache GConfLocaleCache;
 
-GConfLocaleCache* gconf_locale_cache_new           (void);
-void              gconf_locale_cache_free       (GConfLocaleCache* cache);
-void              gconf_locale_cache_expire        (GConfLocaleCache* cache,
+GConfLocaleCache* _gconf_locale_cache_new           (void);
+void              _gconf_locale_cache_free       (GConfLocaleCache* cache);
+void              _gconf_locale_cache_expire        (GConfLocaleCache* cache,
                                                     /* >= max_age is deleted */
                                                     guint max_age_exclusive_in_seconds);
 
 
 /* This API is annoying, but hey it's all GConf internal. No users will see it.
@@ -47,23 +47,23 @@ typedef struct _GConfLocaleList GConfLoc
 
 struct _GConfLocaleList {
   const gchar** list;
 };
 
-void              gconf_locale_list_ref            (GConfLocaleList* list);
-void              gconf_locale_list_unref          (GConfLocaleList* list);
+void              _gconf_locale_list_ref            (GConfLocaleList* list);
+void              _gconf_locale_list_unref          (GConfLocaleList* list);
 
 /* for thread safety, this is going to increment the reference count
    on the locale list. You must unref() when done. This automatically
    adds a cache entry if necessary. locale may be NULL, in which case
    it just gets converted to "C"
 */
-GConfLocaleList*  gconf_locale_cache_get_list      (GConfLocaleCache* cache,
+GConfLocaleList*  _gconf_locale_cache_get_list      (GConfLocaleCache* cache,
                                                     const gchar* locale);
 
 /* Use this if you don't care about the locale cache */
-gchar**           gconf_split_locale               (const gchar* locale);
+gchar**           _gconf_split_locale               (const gchar* locale);
 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
Index: gconf/gconf-internals.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-internals.c,v
retrieving revision 1.135
diff -p -u -5 -r1.135 gconf-internals.c
--- gconf/gconf-internals.c	3 Jan 2006 16:36:30 -0000	1.135
+++ gconf/gconf-internals.c	4 May 2006 11:21:00 -0000
@@ -45,23 +45,23 @@ gboolean gconf_log_debug_messages = FALS
 
 static gboolean gconf_daemon_mode = FALSE;
 static gchar* daemon_ior = NULL;
 
 void
-gconf_set_daemon_mode(gboolean setting)
+_gconf_set_daemon_mode(gboolean setting)
 {
   gconf_daemon_mode = setting;
 }
 
 gboolean
-gconf_in_daemon_mode(void)
+_gconf_in_daemon_mode(void)
 {
   return gconf_daemon_mode;
 }
 
 void
-gconf_set_daemon_ior(const gchar* ior)
+_gconf_set_daemon_ior(const gchar* ior)
 {
   if (daemon_ior != NULL)
     {
       g_free(daemon_ior);
       daemon_ior = NULL;
@@ -70,17 +70,17 @@ gconf_set_daemon_ior(const gchar* ior)
   if (ior != NULL)
     daemon_ior = g_strdup(ior);
 }
 
 const gchar*
-gconf_get_daemon_ior(void)
+_gconf_get_daemon_ior(void)
 {
   return daemon_ior;
 }
 
 gchar*
-gconf_key_directory  (const gchar* key)
+_gconf_key_directory  (const gchar* key)
 {
   const gchar* end;
   gchar* retval;
   int len;
 
@@ -126,21 +126,21 @@ gconf_key_key        (const gchar* key)
 /*
  *  Random stuff 
  */
 
 gboolean
-gconf_file_exists (const gchar* filename)
+_gconf_file_exists (const gchar* filename)
 {
   struct stat s;
   
   g_return_val_if_fail (filename != NULL,FALSE);
   
   return g_stat (filename, &s) == 0;
 }
 
 gboolean
-gconf_file_test(const gchar* filename, int test)
+_gconf_file_test(const gchar* filename, int test)
 {
   struct stat s;
   if(g_stat (filename, &s) != 0)
     return FALSE;
   if(!(test & GCONF_FILE_ISFILE) && S_ISREG(s.st_mode))
@@ -151,11 +151,11 @@ gconf_file_test(const gchar* filename, i
     return FALSE;
   return TRUE;
 }
 
 GConfValue* 
-gconf_value_from_corba_value(const ConfigValue* value)
+_gconf_value_from_corba_value(const ConfigValue* value)
 {
   GConfValue* gval;
   GConfValueType type = GCONF_VALUE_INVALID;
   
   switch (value->_d)
@@ -214,11 +214,11 @@ gconf_value_from_corba_value(const Confi
     case GCONF_VALUE_BOOL:
       gconf_value_set_bool(gval, value->_u.bool_value);
       break;
     case GCONF_VALUE_SCHEMA:
       gconf_value_set_schema_nocopy(gval, 
-                                    gconf_schema_from_corba_schema(&(value->_u.schema_value)));
+                                    _gconf_schema_from_corba_schema(&(value->_u.schema_value)));
       break;
     case GCONF_VALUE_LIST:
       {
         GSList* list = NULL;
         guint i = 0;
@@ -254,11 +254,11 @@ gconf_value_from_corba_value(const Confi
                 /* This is a bit dubious; we cast a ConfigBasicValue to ConfigValue
                    because they have the same initial members, but by the time
                    the CORBA and C specs kick in, not sure we are guaranteed
                    to be able to do this.
                 */
-                val = gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[i]);
+                val = _gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[i]);
                 
                 if (val == NULL)
                   gconf_log(GCL_ERR, _("Couldn't interpret CORBA value for list element"));
                 else if (val->type != gconf_value_get_list_type(gval))
                   gconf_log(GCL_ERR, _("Incorrect type for list element in %s"), G_GNUC_FUNCTION);
@@ -281,14 +281,14 @@ gconf_value_from_corba_value(const Confi
     case GCONF_VALUE_PAIR:
       {
         g_return_val_if_fail(value->_u.pair_value._length == 2, gval);
         
         gconf_value_set_car_nocopy(gval,
-                                   gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[0]));
+                                   _gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[0]));
 
         gconf_value_set_cdr_nocopy(gval,
-                                   gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[1]));
+                                   _gconf_value_from_corba_value((ConfigValue*)&value->_u.list_value.seq._buffer[1]));
       }
       break;
     default:
       g_assert_not_reached();
       break;
@@ -296,11 +296,11 @@ gconf_value_from_corba_value(const Confi
   
   return gval;
 }
 
 void          
-gconf_fill_corba_value_from_gconf_value(const GConfValue *value, 
+_gconf_fill_corba_value_from_gconf_value(const GConfValue *value, 
                                         ConfigValue      *cv)
 {
   if (value == NULL)
     {
       cv->_d = InvalidVal;
@@ -325,11 +325,11 @@ gconf_fill_corba_value_from_gconf_value(
       cv->_d = BoolVal;
       cv->_u.bool_value = gconf_value_get_bool(value);
       break;
     case GCONF_VALUE_SCHEMA:
       cv->_d = SchemaVal;
-      gconf_fill_corba_schema_from_gconf_schema (gconf_value_get_schema(value),
+      _gconf_fill_corba_schema_from_gconf_schema (gconf_value_get_schema(value),
                                                  &cv->_u.schema_value);
       break;
     case GCONF_VALUE_LIST:
       {
         guint n, i;
@@ -377,11 +377,11 @@ gconf_fill_corba_value_from_gconf_value(
         
         i= 0;
         while (list != NULL)
           {
             /* That dubious ConfigBasicValue->ConfigValue cast again */
-            gconf_fill_corba_value_from_gconf_value((GConfValue*)list->data,
+            _gconf_fill_corba_value_from_gconf_value((GConfValue*)list->data,
                                                     (ConfigValue*)&cv->_u.list_value.seq._buffer[i]);
 
             list = g_slist_next(list);
             ++i;
           }
@@ -396,13 +396,13 @@ gconf_fill_corba_value_from_gconf_value(
         cv->_u.pair_value._length = 2;
         cv->_u.pair_value._maximum = 2;
         CORBA_sequence_set_release(&cv->_u.pair_value, TRUE);
         
         /* dubious cast */
-        gconf_fill_corba_value_from_gconf_value (gconf_value_get_car(value),
+        _gconf_fill_corba_value_from_gconf_value (gconf_value_get_car(value),
                                                  (ConfigValue*)&cv->_u.pair_value._buffer[0]);
-        gconf_fill_corba_value_from_gconf_value(gconf_value_get_cdr(value),
+        _gconf_fill_corba_value_from_gconf_value(gconf_value_get_cdr(value),
                                                 (ConfigValue*)&cv->_u.pair_value._buffer[1]);
       }
       break;
       
     case GCONF_VALUE_INVALID:
@@ -414,23 +414,23 @@ gconf_fill_corba_value_from_gconf_value(
       break;
     }
 }
 
 ConfigValue*  
-gconf_corba_value_from_gconf_value (const GConfValue* value)
+_gconf_corba_value_from_gconf_value (const GConfValue* value)
 {
   ConfigValue* cv;
 
   cv = ConfigValue__alloc();
 
-  gconf_fill_corba_value_from_gconf_value(value, cv);
+  _gconf_fill_corba_value_from_gconf_value(value, cv);
 
   return cv;
 }
 
 ConfigValue*  
-gconf_invalid_corba_value (void)
+_gconf_invalid_corba_value (void)
 {
   ConfigValue* cv;
 
   cv = ConfigValue__alloc();
 
@@ -438,24 +438,24 @@ gconf_invalid_corba_value (void)
 
   return cv;
 }
 
 gchar*
-gconf_object_to_string (CORBA_Object obj,
+_gconf_object_to_string (CORBA_Object obj,
                         GError **err)
 {
   CORBA_Environment ev;
   gchar *ior;
   gchar *retval;
   
   CORBA_exception_init (&ev);
 
-  ior = CORBA_ORB_object_to_string (gconf_orb_get (), obj, &ev);
+  ior = CORBA_ORB_object_to_string (_gconf_orb_get (), obj, &ev);
 
   if (ior == NULL)
     {
-      gconf_set_error (err,
+      _gconf_set_error (err,
                        GCONF_ERROR_FAILED,
                        _("Failed to convert object to IOR"));
 
       return NULL;
     }
@@ -520,11 +520,11 @@ gconf_type_from_corba_type(ConfigValueTy
       return GCONF_VALUE_INVALID;
     }
 }
 
 void          
-gconf_fill_corba_schema_from_gconf_schema(const GConfSchema *sc, 
+_gconf_fill_corba_schema_from_gconf_schema(const GConfSchema *sc, 
                                           ConfigSchema      *cs)
 {
   cs->value_type = corba_type_from_gconf_type (gconf_schema_get_type (sc));
   cs->value_list_type = corba_type_from_gconf_type (gconf_schema_get_list_type (sc));
   cs->value_car_type = corba_type_from_gconf_type (gconf_schema_get_car_type (sc));
@@ -541,11 +541,11 @@ gconf_fill_corba_schema_from_gconf_schem
 
     default_val = gconf_schema_get_default_value (sc);
 
     if (default_val)
       {
-        encoded = gconf_value_encode (default_val);
+        encoded = _gconf_value_encode (default_val);
 
         g_assert (encoded != NULL);
 
         cs->encoded_default_value = CORBA_string_dup (encoded);
 
@@ -555,23 +555,23 @@ gconf_fill_corba_schema_from_gconf_schem
       cs->encoded_default_value = CORBA_string_dup ("");
   }
 }
 
 ConfigSchema* 
-gconf_corba_schema_from_gconf_schema (const GConfSchema* sc)
+_gconf_corba_schema_from_gconf_schema (const GConfSchema* sc)
 {
   ConfigSchema* cs;
 
   cs = ConfigSchema__alloc ();
 
-  gconf_fill_corba_schema_from_gconf_schema (sc, cs);
+  _gconf_fill_corba_schema_from_gconf_schema (sc, cs);
 
   return cs;
 }
 
 GConfSchema*  
-gconf_schema_from_corba_schema(const ConfigSchema* cs)
+_gconf_schema_from_corba_schema(const ConfigSchema* cs)
 {
   GConfSchema* sc;
   GConfValueType type = GCONF_VALUE_INVALID;
   GConfValueType list_type = GCONF_VALUE_INVALID;
   GConfValueType car_type = GCONF_VALUE_INVALID;
@@ -622,21 +622,21 @@ gconf_schema_from_corba_schema(const Con
     }
       
   {
     GConfValue* val;
 
-    val = gconf_value_decode(cs->encoded_default_value);
+    val = _gconf_value_decode(cs->encoded_default_value);
 
     if (val)
       gconf_schema_set_default_value_nocopy(sc, val);
   }
   
   return sc;
 }
 
 const gchar* 
-gconf_value_type_to_string(GConfValueType type)
+_gconf_value_type_to_string(GConfValueType type)
 {
   switch (type)
     {
     case GCONF_VALUE_INT:
       return "int";
@@ -659,11 +659,11 @@ gconf_value_type_to_string(GConfValueTyp
       return NULL; /* for warnings */
     }
 }
 
 GConfValueType 
-gconf_value_type_from_string(const gchar* type_str)
+_gconf_value_type_from_string(const gchar* type_str)
 {
   if (strcmp(type_str, "int") == 0)
     return GCONF_VALUE_INT;
   else if (strcmp(type_str, "float") == 0)
     return GCONF_VALUE_FLOAT;
@@ -847,22 +847,22 @@ subst_variables(const gchar* src)
 
   return retval;
 }
 
 GSList *
-gconf_load_source_path(const gchar* filename, GError** err)
+_gconf_load_source_path(const gchar* filename, GError** err)
 {
   FILE* f;
   GSList *l = NULL;
   gchar buf[512];
 
   f = g_fopen(filename, "r");
 
   if (f == NULL)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_FAILED,
+        *err = _gconf_error_new(GCONF_ERROR_FAILED,
                                _("Couldn't open path file `%s': %s\n"), 
                                filename, 
                                g_strerror(errno));
       return NULL;
     }
@@ -899,11 +899,11 @@ gconf_load_source_path(const gchar* file
 	    gchar *tem = varsubst;
 	    varsubst = _gconf_win32_replace_prefix (varsubst);
 	    g_free (tem);
 	  }
 #endif
-          included = gconf_load_source_path (varsubst, NULL);
+          included = _gconf_load_source_path (varsubst, NULL);
           g_free (varsubst);
           
           if (included != NULL)
             l = g_slist_concat (l, included);
         }
@@ -929,11 +929,11 @@ gconf_load_source_path(const gchar* file
 
   if (ferror(f))
     {
       /* This should basically never happen */
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_FAILED,
+        *err = _gconf_error_new(GCONF_ERROR_FAILED,
                                _("Read error on file `%s': %s\n"), 
                                filename,
                                g_strerror(errno));
       /* don't return, we want to go ahead and return any 
          addresses we already loaded. */
@@ -943,11 +943,11 @@ gconf_load_source_path(const gchar* file
 
   return l;
 }
 
 char *
-gconf_address_list_get_persistent_name (GSList *addresses)
+_gconf_address_list_get_persistent_name (GSList *addresses)
 {
   GSList  *tmp;
   GString *str = NULL;
 
   if (!addresses)
@@ -975,11 +975,11 @@ gconf_address_list_get_persistent_name (
 
   return g_string_free (str, FALSE);
 }
 
 GSList *
-gconf_persistent_name_get_address_list (const char *persistent_name)
+_gconf_persistent_name_get_address_list (const char *persistent_name)
 {
   char   delim [2] = { GCONF_DATABASE_LIST_DELIM, '\0' };
   char **address_vector;
 
   address_vector = g_strsplit (persistent_name, delim, -1);
@@ -1004,11 +1004,11 @@ gconf_persistent_name_get_address_list (
       return g_slist_append (NULL, g_strdup (persistent_name));
     }
 }
 
 void
-gconf_address_list_free (GSList *addresses)
+_gconf_address_list_free (GSList *addresses)
 {
   GSList *tmp;
 
   tmp = addresses;
   while (tmp != NULL)
@@ -1065,11 +1065,11 @@ gconf_concat_dir_and_key(const gchar* di
   
   return retval;
 }
 
 gulong
-gconf_string_to_gulong(const gchar* str)
+_gconf_string_to_gulong(const gchar* str)
 {
   gulong retval;
   gchar *end;
   errno = 0;
   retval = strtoul(str, &end, 10);
@@ -1078,11 +1078,11 @@ gconf_string_to_gulong(const gchar* str)
 
   return retval;
 }
 
 gboolean
-gconf_string_to_double(const gchar* str,
+_gconf_string_to_double(const gchar* str,
                        gdouble*     retloc)
 {
   char *end;
 
   errno = 0;
@@ -1095,21 +1095,21 @@ gconf_string_to_double(const gchar* str,
   else
     return TRUE;
 }
 
 gchar*
-gconf_double_to_string (gdouble val)
+_gconf_double_to_string (gdouble val)
 {
   char str[G_ASCII_DTOSTR_BUF_SIZE];
 
   g_ascii_dtostr (str, G_ASCII_DTOSTR_BUF_SIZE, val);
   
   return g_strdup (str);
 }
 
 const gchar*
-gconf_current_locale(void)
+_gconf_current_locale(void)
 {
 #ifdef HAVE_LC_MESSAGES
   return setlocale(LC_MESSAGES, NULL);
 #else
   return setlocale(LC_CTYPE, NULL);
@@ -1224,11 +1224,11 @@ gconf_log(GConfLogPriority pri, const gc
 /*
  * List/pair conversion
  */
 
 GConfValue*
-gconf_value_list_from_primitive_list(GConfValueType list_type, GSList* list,
+_gconf_value_list_from_primitive_list(GConfValueType list_type, GSList* list,
                                      GError **err)
 {
   GSList* value_list;
   GSList* tmp;
 
@@ -1271,11 +1271,11 @@ gconf_value_list_from_primitive_list(GCo
                      
           gconf_value_set_string(val, tmp->data);
           break;
 
         case GCONF_VALUE_SCHEMA:
-          if (!gconf_schema_validate (tmp->data, err))
+          if (!_gconf_schema_validate (tmp->data, err))
             goto error;
           gconf_value_set_schema(val, tmp->data);
           break;
           
         default:
@@ -1342,11 +1342,11 @@ from_primitive(GConfValueType type, gcon
     case GCONF_VALUE_FLOAT:
       gconf_value_set_float(val, *((const gdouble*)address));
       break;
 
     case GCONF_VALUE_SCHEMA:
-      if (!gconf_schema_validate (*((GConfSchema**)address), err))
+      if (!_gconf_schema_validate (*((GConfSchema**)address), err))
         {
           gconf_value_free (val);
           return NULL;
         }
       
@@ -1360,11 +1360,11 @@ from_primitive(GConfValueType type, gcon
 
   return val;
 }
 
 GConfValue*
-gconf_value_pair_from_primitive_pair(GConfValueType car_type,
+_gconf_value_pair_from_primitive_pair(GConfValueType car_type,
                                      GConfValueType cdr_type,
                                      gconstpointer address_of_car,
                                      gconstpointer address_of_cdr,
                                      GError       **err)
 {
@@ -1398,11 +1398,11 @@ gconf_value_pair_from_primitive_pair(GCo
   return pair;
 }
 
 
 GSList*
-gconf_value_list_to_primitive_list_destructive(GConfValue* val,
+_gconf_value_list_to_primitive_list_destructive(GConfValue* val,
                                                GConfValueType list_type,
                                                GError** err)
 {
   GSList* retval;
 
@@ -1413,31 +1413,31 @@ gconf_value_list_to_primitive_list_destr
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   
   if (val->type != GCONF_VALUE_LIST)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
+        *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
                                _("Expected list, got %s"),
-                               gconf_value_type_to_string(val->type));
+                               _gconf_value_type_to_string(val->type));
       gconf_value_free(val);
       return NULL;
     }
 
   if (gconf_value_get_list_type(val) != list_type)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
+        *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
                                _("Expected list of %s, got list of %s"),
-                               gconf_value_type_to_string(list_type),
-                               gconf_value_type_to_string(gconf_value_get_list_type (val)));
+                               _gconf_value_type_to_string(list_type),
+                               _gconf_value_type_to_string(gconf_value_get_list_type (val)));
       gconf_value_free(val);
       return NULL;
     }
 
   g_assert(gconf_value_get_list_type(val) == list_type);
       
-  retval = gconf_value_steal_list (val);
+  retval = _gconf_value_steal_list (val);
       
   gconf_value_free (val);
   val = NULL;
       
   {
@@ -1470,15 +1470,15 @@ gconf_value_list_to_primitive_list_destr
               tmp->data = d;
             }
             break;
 
           case GCONF_VALUE_STRING:
-            tmp->data = gconf_value_steal_string (elem);
+            tmp->data = _gconf_value_steal_string (elem);
             break;
 
           case GCONF_VALUE_SCHEMA:
-            tmp->data = gconf_value_steal_schema (elem);
+            tmp->data = _gconf_value_steal_schema (elem);
             break;
                 
           default:
             g_assert_not_reached();
             break;
@@ -1508,30 +1508,30 @@ primitive_value(gpointer retloc, GConfVa
       *((gdouble*)retloc) = gconf_value_get_float(val);
       break;
 
     case GCONF_VALUE_STRING:
       {
-        *((gchar**)retloc) = gconf_value_steal_string (val);
+        *((gchar**)retloc) = _gconf_value_steal_string (val);
       }
       break;
 
     case GCONF_VALUE_BOOL:
       *((gboolean*)retloc) = gconf_value_get_bool(val);
       break;
 
     case GCONF_VALUE_SCHEMA:
-      *((GConfSchema**)retloc) = gconf_value_steal_schema(val);
+      *((GConfSchema**)retloc) = _gconf_value_steal_schema(val);
       break;
       
     default:
       g_assert_not_reached();
       break;
     }
 }
 
 gboolean
-gconf_value_pair_to_primitive_pair_destructive(GConfValue* val,
+_gconf_value_pair_to_primitive_pair_destructive(GConfValue* val,
                                                GConfValueType car_type,
                                                GConfValueType cdr_type,
                                                gpointer car_retloc,
                                                gpointer cdr_retloc,
                                                GError** err)
@@ -1551,13 +1551,13 @@ gconf_value_pair_to_primitive_pair_destr
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);  
       
   if (val->type != GCONF_VALUE_PAIR)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
+        *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
                                _("Expected pair, got %s"),
-                               gconf_value_type_to_string(val->type));
+                               _gconf_value_type_to_string(val->type));
       gconf_value_free(val);
       return FALSE;
     }
 
   car = gconf_value_get_car(val);
@@ -1565,14 +1565,14 @@ gconf_value_pair_to_primitive_pair_destr
       
   if (car == NULL ||
       cdr == NULL)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, 
+        *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, 
                                _("Expected (%s,%s) pair, got a pair with one or both values missing"),
-                               gconf_value_type_to_string(car_type),
-                               gconf_value_type_to_string(cdr_type));
+                               _gconf_value_type_to_string(car_type),
+                               _gconf_value_type_to_string(cdr_type));
 
       gconf_value_free(val);
       return FALSE;
     }
 
@@ -1581,16 +1581,16 @@ gconf_value_pair_to_primitive_pair_destr
       
   if (car->type != car_type ||
       cdr->type != cdr_type)
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
+        *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH,
                                _("Expected pair of type (%s,%s) got type (%s,%s)"),
-                               gconf_value_type_to_string(car_type),
-                               gconf_value_type_to_string(cdr_type),
-                               gconf_value_type_to_string(car->type),
-                               gconf_value_type_to_string(cdr->type));
+                               _gconf_value_type_to_string(car_type),
+                               _gconf_value_type_to_string(cdr_type),
+                               _gconf_value_type_to_string(car->type),
+                               _gconf_value_type_to_string(cdr->type));
       gconf_value_free(val);
       return FALSE;
     }
 
   primitive_value(car_retloc, car);
@@ -1606,11 +1606,11 @@ gconf_value_pair_to_primitive_pair_destr
 /*
  * Encode/decode
  */
 
 gchar*
-gconf_quote_string   (const gchar* src)
+_gconf_quote_string   (const gchar* src)
 {
   gchar* dest;
   const gchar* s;
   gchar* d;
 
@@ -1664,30 +1664,30 @@ gconf_quote_string   (const gchar* src)
   
   return dest;
 }
 
 gchar*
-gconf_unquote_string (const gchar* str, const gchar** end, GError** err)
+_gconf_unquote_string (const gchar* str, const gchar** end, GError** err)
 {
   gchar* unq;
   gchar* unq_end = NULL;
 
   g_return_val_if_fail(end != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   g_return_val_if_fail(str != NULL, NULL);
   
   unq = g_strdup(str);
 
-  gconf_unquote_string_inplace(unq, &unq_end, err);
+  _gconf_unquote_string_inplace(unq, &unq_end, err);
 
   *end = (str + (unq_end - unq));
 
   return unq;
 }
 
 void
-gconf_unquote_string_inplace (gchar* str, gchar** end, GError** err)
+_gconf_unquote_string_inplace (gchar* str, gchar** end, GError** err)
 {
   gchar* dest;
   gchar* s;
 
   g_return_if_fail(end != NULL);
@@ -1697,11 +1697,11 @@ gconf_unquote_string_inplace (gchar* str
   dest = s = str;
 
   if (*s != '"')
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+        *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                                _("Quoted string doesn't begin with a quotation mark"));
       *end = str;
       return;
     }
 
@@ -1758,11 +1758,11 @@ gconf_unquote_string_inplace (gchar* str
   /* If we reach here this means the close quote was never encountered */
 
   *dest = '\0';
   
   if (err)
-    *err = gconf_error_new(GCONF_ERROR_PARSE_ERROR,
+    *err = _gconf_error_new(GCONF_ERROR_PARSE_ERROR,
                            _("Quoted string doesn't end with a quotation mark"));
   *end = s;
   return;
 }
 
@@ -1864,11 +1864,11 @@ byte_type(gchar byte)
       return GCONF_VALUE_INVALID;
     }
 }
 
 GConfValue*
-gconf_value_decode (const gchar* encoded)
+_gconf_value_decode (const gchar* encoded)
 {
   GConfValueType type;
   GConfValue* val;
   const gchar* s;
   
@@ -1936,11 +1936,11 @@ gconf_value_decode (const gchar* encoded
           g_warning("no comma after types in schema");
 
 	++s;
 
         /* locale */
-        unquoted = gconf_unquote_string(s, &end, NULL);
+        unquoted = _gconf_unquote_string(s, &end, NULL);
 
         gconf_schema_set_locale(sc, unquoted);
 
         g_free(unquoted);
         
@@ -1949,11 +1949,11 @@ gconf_value_decode (const gchar* encoded
 
         ++end;
         s = end;
 
         /* short */
-        unquoted = gconf_unquote_string(s, &end, NULL);
+        unquoted = _gconf_unquote_string(s, &end, NULL);
 
         gconf_schema_set_short_desc(sc, unquoted);
 
         g_free(unquoted);
         
@@ -1962,11 +1962,11 @@ gconf_value_decode (const gchar* encoded
 
         ++end;
         s = end;
 
         /* long */
-        unquoted = gconf_unquote_string(s, &end, NULL);
+        unquoted = _gconf_unquote_string(s, &end, NULL);
 
         gconf_schema_set_long_desc(sc, unquoted);
 
         g_free(unquoted);
         
@@ -1975,13 +1975,13 @@ gconf_value_decode (const gchar* encoded
 
         ++end;
         s = end;
         
         /* default value */
-        unquoted = gconf_unquote_string(s, &end, NULL);
+        unquoted = _gconf_unquote_string(s, &end, NULL);
 
-        gconf_schema_set_default_value_nocopy(sc, gconf_value_decode(unquoted));
+        gconf_schema_set_default_value_nocopy(sc, _gconf_value_decode(unquoted));
 
         g_free(unquoted);
         
         if (*end != '\0')
           g_warning("trailing junk after encoded schema");
@@ -2000,13 +2000,13 @@ gconf_value_decode (const gchar* encoded
             gchar* unquoted;
             const gchar* end;
             
             GConfValue* elem;
             
-            unquoted = gconf_unquote_string(s, &end, NULL);            
+            unquoted = _gconf_unquote_string(s, &end, NULL);            
 
-            elem = gconf_value_decode(unquoted);
+            elem = _gconf_value_decode(unquoted);
 
             g_free(unquoted);
             
             if (elem)
               value_list = g_slist_prepend(value_list, elem);
@@ -2033,13 +2033,13 @@ gconf_value_decode (const gchar* encoded
         const gchar* end;
         
         GConfValue* car;
         GConfValue* cdr;
         
-        unquoted = gconf_unquote_string(s, &end, NULL);            
+        unquoted = _gconf_unquote_string(s, &end, NULL);            
         
-        car = gconf_value_decode(unquoted);
+        car = _gconf_value_decode(unquoted);
 
         g_free(unquoted);
         
         s = end;
         if (*s == ',')
@@ -2047,13 +2047,13 @@ gconf_value_decode (const gchar* encoded
         else
           {
             g_warning("weird character in encoded pair");
           }
         
-        unquoted = gconf_unquote_string(s, &end, NULL);
+        unquoted = _gconf_unquote_string(s, &end, NULL);
         
-        cdr = gconf_value_decode(unquoted);
+        cdr = _gconf_value_decode(unquoted);
         g_free(unquoted);
 
 
         gconf_value_set_car_nocopy(val, car);
         gconf_value_set_cdr_nocopy(val, cdr);
@@ -2067,11 +2067,11 @@ gconf_value_decode (const gchar* encoded
 
   return val;
 }
 
 gchar*
-gconf_value_encode (GConfValue* val)
+_gconf_value_encode (GConfValue* val)
 {
   gchar* retval = NULL;
   
   g_return_val_if_fail(val != NULL, NULL);
 
@@ -2106,45 +2106,45 @@ gconf_value_encode (GConfValue* val)
 			      type_byte(gconf_schema_get_type(sc)),
 			      type_byte(gconf_schema_get_list_type(sc)),
 			      type_byte(gconf_schema_get_car_type(sc)),
 			      type_byte(gconf_schema_get_cdr_type(sc)));
 
-        quoted = gconf_quote_string(gconf_schema_get_locale(sc) ?
+        quoted = _gconf_quote_string(gconf_schema_get_locale(sc) ?
                                     gconf_schema_get_locale(sc) : "");
         retval = g_strconcat(tmp, quoted, ",", NULL);
 
         g_free(tmp);
         g_free(quoted);
 
         tmp = retval;
-        quoted = gconf_quote_string(gconf_schema_get_short_desc(sc) ?
+        quoted = _gconf_quote_string(gconf_schema_get_short_desc(sc) ?
                                     gconf_schema_get_short_desc(sc) : "");
 
         retval = g_strconcat(tmp, quoted, ",", NULL);
 
         g_free(tmp);
         g_free(quoted);
 
 
         tmp = retval;
-        quoted = gconf_quote_string(gconf_schema_get_long_desc(sc) ?
+        quoted = _gconf_quote_string(gconf_schema_get_long_desc(sc) ?
                                     gconf_schema_get_long_desc(sc) : "");
 
         retval = g_strconcat(tmp, quoted, ",", NULL);
 
         g_free(tmp);
         g_free(quoted);
         
 
         if (gconf_schema_get_default_value(sc) != NULL)
-          encoded = gconf_value_encode(gconf_schema_get_default_value(sc));
+          encoded = _gconf_value_encode(gconf_schema_get_default_value(sc));
         else
           encoded = g_strdup("");
 
         tmp = retval;
           
-        quoted = gconf_quote_string(encoded);
+        quoted = _gconf_quote_string(encoded);
 
         retval = g_strconcat(tmp, quoted, NULL);
 
         g_free(tmp);
         g_free(quoted);
@@ -2166,13 +2166,13 @@ gconf_value_encode (GConfValue* val)
             gchar* encoded;
             gchar* quoted;
             
             g_assert(elem != NULL);
 
-            encoded = gconf_value_encode(elem);
+            encoded = _gconf_value_encode(elem);
 
-            quoted = gconf_quote_string(encoded);
+            quoted = _gconf_quote_string(encoded);
 
             g_free(encoded);
 
             {
               gchar* free_me;
@@ -2194,15 +2194,15 @@ gconf_value_encode (GConfValue* val)
         gchar* car_encoded;
         gchar* cdr_encoded;
         gchar* car_quoted;
         gchar* cdr_quoted;
 
-        car_encoded = gconf_value_encode(gconf_value_get_car(val));
-        cdr_encoded = gconf_value_encode(gconf_value_get_cdr(val));
+        car_encoded = _gconf_value_encode(gconf_value_get_car(val));
+        cdr_encoded = _gconf_value_encode(gconf_value_get_cdr(val));
 
-        car_quoted = gconf_quote_string(car_encoded);
-        cdr_quoted = gconf_quote_string(cdr_encoded);
+        car_quoted = _gconf_quote_string(car_encoded);
+        cdr_quoted = _gconf_quote_string(cdr_encoded);
 
         retval = g_strconcat("p", car_quoted, ",", cdr_quoted, NULL);
 
         g_free(car_encoded);
         g_free(cdr_encoded);
@@ -2551,11 +2551,11 @@ read_current_server_and_set_warning (con
           CORBA_Environment ev;
           ConfigServer server;
           
           CORBA_exception_init (&ev);
                   
-          orb = gconf_orb_get ();
+          orb = _gconf_orb_get ();
 
           if (orb == NULL)
             {
               if (warning)
                 g_string_append_printf (warning,
@@ -2600,11 +2600,11 @@ read_current_server (const gchar *iorfil
 
   return server;
 }
 
 GConfLock*
-gconf_get_lock_or_current_holder (const gchar  *lock_directory,
+_gconf_get_lock_or_current_holder (const gchar  *lock_directory,
                                   ConfigServer *current_server,
                                   GError      **err)
 {
   GConfLock* lock;
   
@@ -2614,11 +2614,11 @@ gconf_get_lock_or_current_holder (const 
     *current_server = CORBA_OBJECT_NIL;
   
   if (g_mkdir (lock_directory, 0700) < 0 &&
       errno != EEXIST)
     {
-      gconf_set_error (err,
+      _gconf_set_error (err,
                        GCONF_ERROR_LOCK_FAILED,
                        _("couldn't create directory `%s': %s"),
                        lock_directory, g_strerror (errno));
 
       return NULL;
@@ -2661,21 +2661,21 @@ gconf_get_lock_or_current_holder (const 
 
       g_free (s);
         
       if (retval >= 0)
         {
-          ior = gconf_get_daemon_ior();
+          ior = _gconf_get_daemon_ior();
             
           if (ior == NULL)
             retval = write (lock->lock_fd, "none", 4);
           else
             retval = write (lock->lock_fd, ior, strlen (ior));
         }
 
       if (retval < 0)
         {
-          gconf_set_error (err,
+          _gconf_set_error (err,
                            GCONF_ERROR_LOCK_FAILED,
                            _("Can't write to file `%s': %s"),
                            lock->iorfile, g_strerror (errno));
 
           g_unlink (lock->iorfile);
@@ -2687,18 +2687,18 @@ gconf_get_lock_or_current_holder (const 
 
   return lock;
 }
 
 GConfLock*
-gconf_get_lock (const gchar *lock_directory,
+_gconf_get_lock (const gchar *lock_directory,
                 GError     **err)
 {
-  return gconf_get_lock_or_current_holder (lock_directory, NULL, err);
+  return _gconf_get_lock_or_current_holder (lock_directory, NULL, err);
 }
 
 gboolean
-gconf_release_lock (GConfLock *lock,
+_gconf_release_lock (GConfLock *lock,
                     GError   **err)
 {
   gboolean retval;
   char *uniquefile;
   
@@ -2807,11 +2807,11 @@ gconf_release_lock (GConfLock *lock,
 
 /* This function doesn't try to see if the lock is valid or anything
  * of the sort; it just reads it. It does do the object_to_string
  */
 ConfigServer
-gconf_get_current_lock_holder  (const gchar *lock_directory,
+_gconf_get_current_lock_holder  (const gchar *lock_directory,
                                 GString     *failure_log)
 {
   char *iorfile;
   ConfigServer server;
 
@@ -2820,16 +2820,16 @@ gconf_get_current_lock_holder  (const gc
   g_free (iorfile);
   return server;
 }
 
 void
-gconf_daemon_blow_away_locks (void)
+_gconf_daemon_blow_away_locks (void)
 {
   char *lock_directory;
   char *iorfile;
   
-  lock_directory = gconf_get_lock_dir ();
+  lock_directory = _gconf_get_lock_dir ();
 
   iorfile = g_strconcat (lock_directory, "/ior", NULL);
 
   if (g_unlink (iorfile) < 0)
     g_printerr (_("Failed to unlink lock file %s: %s\n"),
@@ -2840,11 +2840,11 @@ gconf_daemon_blow_away_locks (void)
 }
 
 static CORBA_ORB gconf_orb = CORBA_OBJECT_NIL;      
 
 CORBA_ORB
-gconf_orb_get (void)
+_gconf_orb_get (void)
 {
   if (gconf_orb == CORBA_OBJECT_NIL)
     {
       CORBA_Environment ev;
       int argc = 1;
@@ -2862,11 +2862,11 @@ gconf_orb_get (void)
 
   return gconf_orb;
 }
 
 int
-gconf_orb_release (void)
+_gconf_orb_release (void)
 {
   int ret = 0;
 
   if (gconf_orb != CORBA_OBJECT_NIL)
     {
@@ -2889,13 +2889,13 @@ gconf_orb_release (void)
 
   return ret;
 }
 
 char*
-gconf_get_daemon_dir (void)
+_gconf_get_daemon_dir (void)
 {  
-  if (gconf_use_local_locks ())
+  if (_gconf_use_local_locks ())
     {
       char *s;
       char *subdir;
 
       subdir = g_strconcat ("gconfd-", g_get_user_name (), NULL);
@@ -2916,16 +2916,16 @@ gconf_get_daemon_dir (void)
       return g_strconcat (home, "/.gconfd", NULL);
     }
 }
 
 char*
-gconf_get_lock_dir (void)
+_gconf_get_lock_dir (void)
 {
   char *gconfd_dir;
   char *lock_dir;
   
-  gconfd_dir = gconf_get_daemon_dir ();
+  gconfd_dir = _gconf_get_daemon_dir ();
   lock_dir = g_strconcat (gconfd_dir, "/lock", NULL);
 
   g_free (gconfd_dir);
   return lock_dir;
 }
@@ -2960,11 +2960,11 @@ close_fd_func (gpointer data)
 #define close_fd_func NULL
 
 #endif
 
 ConfigServer
-gconf_activate_server (gboolean  start_if_not_found,
+_gconf_activate_server (gboolean  start_if_not_found,
                        GError  **error)
 {
   ConfigServer server = CORBA_OBJECT_NIL;
   int p[2] = { -1, -1 };
   char buf[1];
@@ -2977,11 +2977,11 @@ gconf_activate_server (gboolean  start_i
   CORBA_Environment ev;
   gboolean dir_accessible;
 
   failure_log = g_string_new (NULL);
   
-  gconfd_dir = gconf_get_daemon_dir ();
+  gconfd_dir = _gconf_get_daemon_dir ();
   
   dir_accessible = g_stat (gconfd_dir, &statbuf) >= 0;
 
   if (!dir_accessible && errno != ENOENT)
     {
@@ -2990,12 +2990,12 @@ gconf_activate_server (gboolean  start_i
 		 gconfd_dir, g_strerror (errno));
     }
   else if (dir_accessible)
     {
       g_string_append (failure_log, " 1: ");
-      lock_dir = gconf_get_lock_dir ();
-      server = gconf_get_current_lock_holder (lock_dir, failure_log);
+      lock_dir = _gconf_get_lock_dir ();
+      server = _gconf_get_current_lock_holder (lock_dir, failure_log);
       g_free (lock_dir);
 
       /* Confirm server exists */
       CORBA_exception_init (&ev);
 
@@ -3068,12 +3068,12 @@ gconf_activate_server (gboolean  start_i
   
       /* Block until server starts up */
       read (p[0], buf, 1);
 
       g_string_append (failure_log, " 2: ");
-      lock_dir = gconf_get_lock_dir ();
-      server = gconf_get_current_lock_holder (lock_dir, failure_log);
+      lock_dir = _gconf_get_lock_dir ();
+      server = _gconf_get_current_lock_holder (lock_dir, failure_log);
       g_free (lock_dir);
     }
   
  out:
   if (server == CORBA_OBJECT_NIL &&
@@ -3094,11 +3094,11 @@ gconf_activate_server (gboolean  start_i
   
   return server;
 }
 
 gboolean
-gconf_CORBA_Object_equal (gconstpointer a, gconstpointer b)
+_gconf_CORBA_Object_equal (gconstpointer a, gconstpointer b)
 {
   CORBA_Environment ev;
   CORBA_Object _obj_a = (gpointer)a;
   CORBA_Object _obj_b = (gpointer)b;
   gboolean retval;
@@ -3109,11 +3109,11 @@ gconf_CORBA_Object_equal (gconstpointer 
 
   return retval;
 }
 
 guint
-gconf_CORBA_Object_hash (gconstpointer key)
+_gconf_CORBA_Object_hash (gconstpointer key)
 {
   CORBA_Environment ev;
   CORBA_Object _obj = (gpointer)key;
   CORBA_unsigned_long retval;
 
@@ -3140,11 +3140,11 @@ _gconf_init_i18n (void)
 }
 
 enum { UNKNOWN, LOCAL, NORMAL };
 
 gboolean
-gconf_use_local_locks (void)
+_gconf_use_local_locks (void)
 {
   static int local_locks = UNKNOWN;
   
   if (local_locks == UNKNOWN)
     {
Index: gconf/gconf.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf.c,v
retrieving revision 1.151
diff -p -u -5 -r1.151 gconf.c
--- gconf/gconf.c	8 Dec 2005 13:00:58 -0000	1.151
+++ gconf/gconf.c	4 May 2006 11:21:00 -0000
@@ -44,26 +44,26 @@ static void gconf_detach_config_server(v
 
 /* Maximum number of times to try re-spawning the server if it's down. */
 #define MAX_RETRIES 1
 
 gboolean
-gconf_key_check(const gchar* key, GError** err)
+_gconf_key_check(const gchar* key, GError** err)
 {
   gchar* why = NULL;
 
   if (key == NULL)
     {
       if (err)
-        *err = gconf_error_new (GCONF_ERROR_BAD_KEY,
+        *err = _gconf_error_new (GCONF_ERROR_BAD_KEY,
                                 _("Key \"%s\" is NULL"),
                                 key);
       return FALSE;
     }
   else if (!gconf_valid_key (key, &why))
     {
       if (err)
-        *err = gconf_error_new (GCONF_ERROR_BAD_KEY, _("\"%s\": %s"),
+        *err = _gconf_error_new (GCONF_ERROR_BAD_KEY, _("\"%s\": %s"),
                                 key, why);
       g_free(why);
       return FALSE;
     }
   return TRUE;
@@ -220,29 +220,29 @@ gconf_engine_blank (gboolean remote)
   
   return conf;
 }
 
 void
-gconf_engine_set_owner (GConfEngine *engine,
+_gconf_engine_set_owner (GConfEngine *engine,
                         gpointer     client)
 {
   g_return_if_fail (engine->owner_use_count == 0);
   
   engine->owner = client;
 }
 
 void
-gconf_engine_push_owner_usage (GConfEngine *engine,
+_gconf_engine_push_owner_usage (GConfEngine *engine,
                                gpointer     client)
 {
   g_return_if_fail (engine->owner == client);
 
   engine->owner_use_count += 1;
 }
 
 void
-gconf_engine_pop_owner_usage  (GConfEngine *engine,
+_gconf_engine_pop_owner_usage  (GConfEngine *engine,
                                gpointer     client)
 {
   g_return_if_fail (engine->owner == client);
   g_return_if_fail (engine->owner_use_count > 0);
 
@@ -283,12 +283,12 @@ gconf_engine_set_database (GConfEngine *
 
   conf->database = db;
 
   if (engines_by_db == NULL)
     engines_by_db = g_hash_table_new_full (
-	    (GHashFunc) gconf_CORBA_Object_hash,
-	    (GCompareFunc) gconf_CORBA_Object_equal,
+	    (GHashFunc) _gconf_CORBA_Object_hash,
+	    (GCompareFunc) _gconf_CORBA_Object_equal,
 	    NULL,
 	    database_rec_release);
   
   g_hash_table_insert (engines_by_db, conf->database, conf);  
 }
@@ -377,11 +377,11 @@ gconf_engine_connect (GConfEngine *conf,
     return FALSE;
 
   if (CORBA_Object_is_nil (db, &ev))
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_BAD_ADDRESS,
+        *err = _gconf_error_new(GCONF_ERROR_BAD_ADDRESS,
                                _("Server couldn't resolve the address `%s'"),
                                conf->persistent_address);
           
       return FALSE;
     }
@@ -416,11 +416,11 @@ register_engine (GConfEngine *conf)
   g_return_if_fail (conf->addresses != NULL);
 
   g_assert (conf->persistent_address == NULL);
 
   conf->persistent_address = 
-          gconf_address_list_get_persistent_name (conf->addresses);
+          _gconf_address_list_get_persistent_name (conf->addresses);
 
   if (engines_by_address == NULL)
     engines_by_address = g_hash_table_new (g_str_hash, g_str_equal);
 
   g_hash_table_insert (engines_by_address, conf->persistent_address, conf);
@@ -451,11 +451,11 @@ lookup_engine (GSList *addresses)
   if (engines_by_address != NULL)
     {
       GConfEngine *retval;
       char        *key;
 
-      key = gconf_address_list_get_persistent_name (addresses);
+      key = _gconf_address_list_get_persistent_name (addresses);
 
       retval = g_hash_table_lookup (engines_by_address, key);
 
       g_free (key);
 
@@ -478,18 +478,18 @@ gconf_engine_get_local      (const gchar
   GConfSource* source;
 
   g_return_val_if_fail(address != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   
-  source = gconf_resolve_address(address, err);
+  source = _gconf_resolve_address(address, err);
 
   if (source == NULL)
     return NULL;
   
   conf = gconf_engine_blank(FALSE);
 
-  conf->local_sources = gconf_sources_new_from_source(source);
+  conf->local_sources = _gconf_sources_new_from_source(source);
 
   g_assert (gconf_engine_is_local (conf));
   
   return conf;
 }
@@ -503,11 +503,11 @@ gconf_engine_get_local_for_addresses (GS
   g_return_val_if_fail (addresses != NULL, NULL);
   g_return_val_if_fail (err == NULL || *err == NULL, NULL);
   
   conf = gconf_engine_blank (FALSE);
 
-  conf->local_sources = gconf_sources_new_from_addresses (addresses, err);
+  conf->local_sources = _gconf_sources_new_from_addresses (addresses, err);
 
   g_assert (gconf_engine_is_local (conf));
   
   return conf;
 }
@@ -634,11 +634,11 @@ gconf_engine_unref(GConfEngine* conf)
   if (conf->refcount == 0)
     {
       if (gconf_engine_is_local(conf))
         {
           if (conf->local_sources != NULL)
-            gconf_sources_free(conf->local_sources);
+            _gconf_sources_free(conf->local_sources);
         }
       else
         {
           /* Remove all connections associated with this GConf */
           GSList* removed;
@@ -689,11 +689,11 @@ gconf_engine_unref(GConfEngine* conf)
               (* conf->dnotify) (conf->user_data);
             }
           
           if (conf->addresses)
 	    {
-	      gconf_address_list_free (conf->addresses);
+	      _gconf_address_list_free (conf->addresses);
 	      conf->addresses = NULL;
 	    }
 
 	  if (conf->persistent_address)
 	    {
@@ -755,11 +755,11 @@ gconf_engine_notify_add(GConfEngine* con
   CHECK_OWNER_USE (conf);
   
   if (gconf_engine_is_local(conf))
     {
       if (err)
-        *err = gconf_error_new(GCONF_ERROR_LOCAL_ENGINE,
+        *err = _gconf_error_new(GCONF_ERROR_LOCAL_ENGINE,
                                _("Can't add notifications to a local configuration source"));
 
       return 0;
     }
 
@@ -904,23 +904,23 @@ gconf_engine_get_fuller (GConfEngine *co
   g_return_val_if_fail(key != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return NULL;
 
   if (gconf_engine_is_local(conf))
     {
       gchar** locale_list;
       gboolean tmp_is_default = FALSE;
       gboolean tmp_is_writable = TRUE;
       gchar *tmp_schema_name = NULL;
       
-      locale_list = gconf_split_locale(locale);
+      locale_list = _gconf_split_locale(locale);
       
-      val = gconf_sources_query_value(conf->local_sources,
+      val = _gconf_sources_query_value(conf->local_sources,
                                       key,
                                       (const gchar**)locale_list,
                                       use_schema_default,
                                       &tmp_is_default,
                                       &tmp_is_writable,
@@ -964,11 +964,11 @@ gconf_engine_get_fuller (GConfEngine *co
 
 
   corba_schema_name = NULL;
   cv = ConfigDatabase2_lookup_with_schema_name (db,
                                                 (gchar*)key, (gchar*)
-                                                (locale ? locale : gconf_current_locale()),
+                                                (locale ? locale : _gconf_current_locale()),
                                                 use_schema_default,
                                                 &corba_schema_name,
                                                 &is_default,
                                                 &is_writable,
                                                 &ev);
@@ -980,11 +980,11 @@ gconf_engine_get_fuller (GConfEngine *co
       CORBA_exception_free (&ev);
       CORBA_exception_init (&ev);
       
       cv = ConfigDatabase_lookup_with_locale(db,
                                              (gchar*)key, (gchar*)
-                                             (locale ? locale : gconf_current_locale()),
+                                             (locale ? locale : _gconf_current_locale()),
                                              use_schema_default,
                                              &is_default,
                                              &is_writable,
                                              &ev);
     }
@@ -1005,11 +1005,11 @@ gconf_engine_get_fuller (GConfEngine *co
       /* NOTE: don't free cv since we got an exception! */
       return NULL;
     }
   else
     {
-      val = gconf_value_from_corba_value(cv);
+      val = _gconf_value_from_corba_value(cv);
       CORBA_free(cv);
 
       if (is_default_p)
         *is_default_p = !!is_default;
       if (is_writable_p)
@@ -1124,20 +1124,20 @@ gconf_engine_get_default_from_schema (GC
   g_return_val_if_fail(key != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return NULL;
 
   if (gconf_engine_is_local(conf))
     {
       gchar** locale_list;
 
-      locale_list = gconf_split_locale(gconf_current_locale());
+      locale_list = _gconf_split_locale(_gconf_current_locale());
       
-      val = gconf_sources_query_default_value(conf->local_sources,
+      val = _gconf_sources_query_default_value(conf->local_sources,
                                               key,
                                               (const gchar**)locale_list,
                                               NULL,
                                               err);
 
@@ -1162,11 +1162,11 @@ gconf_engine_get_default_from_schema (GC
       return NULL;
     }
 
   cv = ConfigDatabase_lookup_default_value(db,
                                            (gchar*)key,
-                                           (gchar*)gconf_current_locale(),
+                                           (gchar*)_gconf_current_locale(),
                                            &ev);
   
   if (gconf_server_broken(&ev))
     {
       if (tries < MAX_RETRIES)
@@ -1183,11 +1183,11 @@ gconf_engine_get_default_from_schema (GC
       /* NOTE: don't free cv since we got an exception! */
       return NULL;
     }
   else
     {
-      val = gconf_value_from_corba_value(cv);
+      val = _gconf_value_from_corba_value(cv);
       CORBA_free(cv);
 
       return val;
     }
 }
@@ -1211,21 +1211,21 @@ gconf_engine_set (GConfEngine* conf, con
                         (gconf_value_get_list_type(value) != GCONF_VALUE_INVALID), FALSE);
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return FALSE;
 
-  if (!gconf_value_validate (value, err))
+  if (!_gconf_value_validate (value, err))
     return FALSE;
   
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_set_value(conf->local_sources, key, value, NULL, &error);
+      _gconf_sources_set_value(conf->local_sources, key, value, NULL, &error);
 
       if (error != NULL)
         {
           if (err)
             *err = error;
@@ -1252,11 +1252,11 @@ gconf_engine_set (GConfEngine* conf, con
       g_return_val_if_fail(err == NULL || *err != NULL, FALSE);
 
       return FALSE;
     }
 
-  cv = gconf_corba_value_from_gconf_value (value);
+  cv = _gconf_corba_value_from_gconf_value (value);
 
   ConfigDatabase_set(db,
                      (gchar*)key, cv,
                      &ev);
 
@@ -1292,18 +1292,18 @@ gconf_engine_unset (GConfEngine* conf, c
   g_return_val_if_fail (key != NULL, FALSE);
   g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return FALSE;
 
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_unset_value(conf->local_sources, key, NULL, NULL, &error);
+      _gconf_sources_unset_value(conf->local_sources, key, NULL, NULL, &error);
 
       if (error != NULL)
         {
           if (err)
             *err = error;
@@ -1367,11 +1367,11 @@ gconf_engine_unset (GConfEngine* conf, c
  * failure is returned in @err.
  *
  * Returns: %FALSE if error is set
  **/
 gboolean
-gconf_engine_recursive_unset (GConfEngine    *conf,
+_gconf_engine_recursive_unset (GConfEngine    *conf,
                               const char     *key,
                               GConfUnsetFlags flags,
                               GError        **err)
 {
   CORBA_Environment ev;
@@ -1383,18 +1383,18 @@ gconf_engine_recursive_unset (GConfEngin
   g_return_val_if_fail (key != NULL, FALSE);
   g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check (key, err))
+  if (!_gconf_key_check (key, err))
     return FALSE;
 
   if (gconf_engine_is_local (conf))
     {
       GError* error = NULL;
       
-      gconf_sources_recursive_unset (conf->local_sources, key, NULL,
+      _gconf_sources_recursive_unset (conf->local_sources, key, NULL,
                                      flags, NULL, &error);
 
       if (error != NULL)
         {
           if (err)
@@ -1459,21 +1459,21 @@ gconf_engine_associate_schema  (GConfEng
 
   g_return_val_if_fail (conf != NULL, FALSE);
   g_return_val_if_fail (key != NULL, FALSE);
   g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
   
-  if (!gconf_key_check (key, err))
+  if (!_gconf_key_check (key, err))
     return FALSE;
 
-  if (schema_key && !gconf_key_check (schema_key, err))
+  if (schema_key && !_gconf_key_check (schema_key, err))
     return FALSE;
 
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_set_schema (conf->local_sources, key, schema_key, &error);
+      _gconf_sources_set_schema (conf->local_sources, key, schema_key, &error);
 
       if (error != NULL)
         {
           if (err)
             *err = error;
@@ -1564,23 +1564,23 @@ gconf_engine_all_entries(GConfEngine* co
   g_return_val_if_fail(dir != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return NULL;
 
 
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       gchar** locale_list;
       GSList* retval;
       
-      locale_list = gconf_split_locale(gconf_current_locale());
+      locale_list = _gconf_split_locale(_gconf_current_locale());
       
-      retval = gconf_sources_all_entries(conf->local_sources,
+      retval = _gconf_sources_all_entries(conf->local_sources,
                                          dir,
                                          (const gchar**)locale_list,
                                          &error);
 
       if (locale_list)
@@ -1622,11 +1622,11 @@ gconf_engine_all_entries(GConfEngine* co
 
   schema_names = NULL;
   
   ConfigDatabase2_all_entries_with_schema_name (db,
                                                 (gchar*)dir,
-                                                (gchar*)gconf_current_locale(),
+                                                (gchar*)_gconf_current_locale(),
                                                 &keys, &values, &schema_names,
                                                 &is_defaults, &is_writables,
                                                 &ev);
   
   if (ev._major == CORBA_SYSTEM_EXCEPTION &&
@@ -1636,11 +1636,11 @@ gconf_engine_all_entries(GConfEngine* co
       CORBA_exception_free (&ev);
       CORBA_exception_init (&ev);
       
       ConfigDatabase_all_entries(db,
                                  (gchar*)dir,
-                                 (gchar*)gconf_current_locale(),
+                                 (gchar*)_gconf_current_locale(),
                                  &keys, &values, &is_defaults, &is_writables,
                                  &ev);
     }
 
   if (gconf_server_broken(&ev))
@@ -1669,11 +1669,11 @@ gconf_engine_all_entries(GConfEngine* co
     {
       GConfEntry* pair;
 
       pair = 
         gconf_entry_new_nocopy(gconf_concat_dir_and_key (dir, keys->_buffer[i]),
-                               gconf_value_from_corba_value(&(values->_buffer[i])));
+                               _gconf_value_from_corba_value(&(values->_buffer[i])));
 
       gconf_entry_set_is_default (pair, is_defaults->_buffer[i]);
       gconf_entry_set_is_writable (pair, is_writables->_buffer[i]);
       if (schema_names)
         {
@@ -1730,19 +1730,19 @@ gconf_engine_all_dirs(GConfEngine* conf,
   g_return_val_if_fail(dir != NULL, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return NULL;
 
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       GSList* retval;
       
-      retval = gconf_sources_all_dirs(conf->local_sources,
+      retval = _gconf_sources_all_dirs(conf->local_sources,
                                       dir,
                                       &error);
       
       if (error != NULL)
         {
@@ -1829,11 +1829,11 @@ gconf_engine_suggest_sync(GConfEngine* c
   
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_sync_all(conf->local_sources,
+      _gconf_sources_sync_all(conf->local_sources,
                              &error);
       
       if (error != NULL)
         {
           if (err)
@@ -1897,11 +1897,11 @@ gconf_clear_cache(GConfEngine* conf, GEr
   
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_clear_cache(conf->local_sources);
+      _gconf_sources_clear_cache(conf->local_sources);
       
       if (error != NULL)
         {
           if (err)
             *err = error;
@@ -1959,11 +1959,11 @@ gconf_synchronous_sync(GConfEngine* conf
 
   if (gconf_engine_is_local(conf))
     {
       GError* error = NULL;
       
-      gconf_sources_sync_all(conf->local_sources, &error);
+      _gconf_sources_sync_all(conf->local_sources, &error);
       
       if (error != NULL)
         {
           if (err)
             *err = error;
@@ -2021,16 +2021,16 @@ gconf_engine_dir_exists(GConfEngine *con
   g_return_val_if_fail(dir != NULL, FALSE);
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
 
   CHECK_OWNER_USE (conf);
   
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return FALSE;
   
   if (gconf_engine_is_local(conf))
     {
-      return gconf_sources_dir_exists(conf->local_sources,
+      return _gconf_sources_dir_exists(conf->local_sources,
                                       dir,
                                       err);
     }
 
   g_assert(!gconf_engine_is_local(conf));
@@ -2083,16 +2083,16 @@ gconf_engine_remove_dir (GConfEngine* co
   g_return_if_fail(err == NULL || *err == NULL);
 
   /* FIXME we have no GConfClient method for doing this */
   /*   CHECK_OWNER_USE (conf); */
   
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return;
 
   if (gconf_engine_is_local(conf))
     {
-      gconf_sources_remove_dir(conf->local_sources, dir, err);
+      _gconf_sources_remove_dir(conf->local_sources, dir, err);
       return;
     }
 
   CORBA_exception_init(&ev);
   
@@ -2202,11 +2202,11 @@ try_to_contact_server (gboolean start_if
                        GError **err)
 {
   CORBA_Environment ev;
   
   /* Try to launch server */      
-  server = gconf_activate_server (start_if_not_found,
+  server = _gconf_activate_server (start_if_not_found,
                                   err);
     
   /* Try to ping server, by adding ourselves as a client */
   CORBA_exception_init (&ev);   
 
@@ -2302,11 +2302,11 @@ gconf_detach_config_server(void)
 int
 gconf_debug_shutdown (void)
 {
   gconf_detach_config_server ();
 
-  return gconf_orb_release ();
+  return _gconf_orb_release ();
 }
 
 static void notify                  (PortableServer_Servant     servant,
                                      ConfigDatabase             db,
                                      CORBA_unsigned_long        cnxn,
@@ -2385,11 +2385,11 @@ notify(PortableServer_Servant servant,
                 (guint)server_id);
 #endif
       return;
     }
 
-  gvalue = gconf_value_from_corba_value(value);
+  gvalue = _gconf_value_from_corba_value(value);
 
   entry = gconf_entry_new_nocopy (g_strdup (key),
                                   gvalue);
   gconf_entry_set_is_default (entry, is_default);
   gconf_entry_set_is_writable (entry, is_writable);
@@ -2432,15 +2432,15 @@ update_listener (PortableServer_Servant 
         conf = default_engine;
       else
         {
           GSList  *addresses;
 
-          addresses = gconf_persistent_name_get_address_list (address);
+          addresses = _gconf_persistent_name_get_address_list (address);
     
           conf = lookup_engine (addresses);
     
-          gconf_address_list_free (addresses);
+          _gconf_address_list_free (addresses);
         }
 
       if (conf)
         gconf_engine_set_database (conf,
                                    CORBA_Object_duplicate (db, &ev));
@@ -2503,11 +2503,11 @@ gconf_get_config_listener(void)
       POA_ConfigListener__init (&poa_listener_servant, &ev);
       
       g_assert (ev._major == CORBA_NO_EXCEPTION);
 
       poa =
-        (PortableServer_POA) CORBA_ORB_resolve_initial_references (gconf_orb_get (),
+        (PortableServer_POA) CORBA_ORB_resolve_initial_references (_gconf_orb_get (),
                                                                    "RootPOA", &ev);
 
       g_assert (ev._major == CORBA_NO_EXCEPTION);
 
       poa_mgr = PortableServer_POA__get_the_POAManager (poa, &ev);
@@ -2995,11 +2995,11 @@ ctable_reinstall (CnxnTable* ct,
 /*
  * Daemon control
  */
 
 void          
-gconf_shutdown_daemon (GError** err)
+_gconf_shutdown_daemon (GError** err)
 {
   CORBA_Environment ev;
   ConfigServer cs;
 
   cs = gconf_get_config_server (FALSE, err); /* Don't want to spawn it if it's already down */
@@ -3022,19 +3022,19 @@ gconf_shutdown_daemon (GError** err)
   ConfigServer_shutdown (cs, &ev);
 
   if (ev._major != CORBA_NO_EXCEPTION)
     {
       if (err)
-        *err = gconf_error_new (GCONF_ERROR_FAILED, _("Failure shutting down config server: %s"),
+        *err = _gconf_error_new (GCONF_ERROR_FAILED, _("Failure shutting down config server: %s"),
                                 CORBA_exception_id (&ev));
 
       CORBA_exception_free(&ev);
     }
 }
 
 gboolean
-gconf_ping_daemon(void)
+_gconf_ping_daemon(void)
 {
   ConfigServer cs;
   
   cs = gconf_get_config_server(FALSE, NULL); /* ignore error, since whole point is to see if server is reachable */
 
@@ -3043,11 +3043,11 @@ gconf_ping_daemon(void)
   else
     return TRUE;
 }
 
 gboolean
-gconf_spawn_daemon(GError** err)
+_gconf_spawn_daemon(GError** err)
 {
   ConfigServer cs;
 
   cs = gconf_get_config_server(TRUE, err);
 
@@ -3083,12 +3083,12 @@ gconf_engine_get_float (GConfEngine* con
       gdouble retval;
       
       if (val->type != GCONF_VALUE_FLOAT)
         {
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected float, got %s"),
-                                    gconf_value_type_to_string(val->type));
+            *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected float, got %s"),
+                                    _gconf_value_type_to_string(val->type));
           gconf_value_free(val);
           return deflt;
         }
 
       retval = gconf_value_get_float(val);
@@ -3118,12 +3118,12 @@ gconf_engine_get_int   (GConfEngine* con
       gint retval;
 
       if (val->type != GCONF_VALUE_INT)
         {
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected int, got %s"),
-                                    gconf_value_type_to_string(val->type));
+            *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected int, got %s"),
+                                    _gconf_value_type_to_string(val->type));
           gconf_value_free(val);
           return deflt;
         }
 
       retval = gconf_value_get_int(val);
@@ -3153,17 +3153,17 @@ gconf_engine_get_string(GConfEngine* con
       gchar* retval;
 
       if (val->type != GCONF_VALUE_STRING)
         {
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected string, got %s"),
-                                    gconf_value_type_to_string(val->type));
+            *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected string, got %s"),
+                                    _gconf_value_type_to_string(val->type));
           gconf_value_free(val);
           return deflt ? g_strdup(deflt) : NULL;
         }
 
-      retval = gconf_value_steal_string (val);
+      retval = _gconf_value_steal_string (val);
       gconf_value_free (val);
 
       return retval;
     }
 }
@@ -3187,12 +3187,12 @@ gconf_engine_get_bool  (GConfEngine* con
       gboolean retval;
 
       if (val->type != GCONF_VALUE_BOOL)
         {
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected bool, got %s"),
-                                    gconf_value_type_to_string(val->type));
+            *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected bool, got %s"),
+                                    _gconf_value_type_to_string(val->type));
           gconf_value_free(val);
           return deflt;
         }
 
       retval = gconf_value_get_bool(val);
@@ -3209,28 +3209,28 @@ gconf_engine_get_schema  (GConfEngine* c
   GConfValue* val;
 
   g_return_val_if_fail(conf != NULL, NULL);
   g_return_val_if_fail(key != NULL, NULL);
   
-  val = gconf_engine_get_with_locale(conf, key, gconf_current_locale(), err);
+  val = gconf_engine_get_with_locale(conf, key, _gconf_current_locale(), err);
 
   if (val == NULL)
     return NULL;
   else
     {
       GConfSchema* retval;
 
       if (val->type != GCONF_VALUE_SCHEMA)
         {
           if (err)
-            *err = gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected schema, got %s"),
-                                    gconf_value_type_to_string(val->type));
+            *err = _gconf_error_new(GCONF_ERROR_TYPE_MISMATCH, _("Expected schema, got %s"),
+                                    _gconf_value_type_to_string(val->type));
           gconf_value_free(val);
           return NULL;
         }
 
-      retval = gconf_value_steal_schema (val);
+      retval = _gconf_value_steal_schema (val);
       gconf_value_free (val);
 
       return retval;
     }
 }
@@ -3246,18 +3246,18 @@ gconf_engine_get_list    (GConfEngine* c
   g_return_val_if_fail(list_type != GCONF_VALUE_INVALID, NULL);
   g_return_val_if_fail(list_type != GCONF_VALUE_LIST, NULL);
   g_return_val_if_fail(list_type != GCONF_VALUE_PAIR, NULL);
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   
-  val = gconf_engine_get_with_locale(conf, key, gconf_current_locale(), err);
+  val = gconf_engine_get_with_locale(conf, key, _gconf_current_locale(), err);
 
   if (val == NULL)
     return NULL;
   else
     {
       /* This type-checks the value */
-      return gconf_value_list_to_primitive_list_destructive(val, list_type, err);
+      return _gconf_value_list_to_primitive_list_destructive(val, list_type, err);
     }
 }
 
 gboolean
 gconf_engine_get_pair    (GConfEngine* conf, const gchar* key,
@@ -3278,11 +3278,11 @@ gconf_engine_get_pair    (GConfEngine* c
   g_return_val_if_fail(cdr_type != GCONF_VALUE_PAIR, FALSE);
   g_return_val_if_fail(car_retloc != NULL, FALSE);
   g_return_val_if_fail(cdr_retloc != NULL, FALSE);
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);  
   
-  val = gconf_engine_get_with_locale(conf, key, gconf_current_locale(), &error);
+  val = gconf_engine_get_with_locale(conf, key, _gconf_current_locale(), &error);
 
   if (error != NULL)
     {
       g_assert(val == NULL);
       
@@ -3299,11 +3299,11 @@ gconf_engine_get_pair    (GConfEngine* c
       return TRUE;
     }
   else
     {
       /* Destroys val */
-      return gconf_value_pair_to_primitive_pair_destructive(val,
+      return _gconf_value_pair_to_primitive_pair_destructive(val,
                                                             car_type, cdr_type,
                                                             car_retloc, cdr_retloc,
                                                             err);
     }
 }
@@ -3437,11 +3437,11 @@ gconf_engine_set_list    (GConfEngine* c
   g_return_val_if_fail(list_type != GCONF_VALUE_INVALID, FALSE);
   g_return_val_if_fail(list_type != GCONF_VALUE_LIST, FALSE);
   g_return_val_if_fail(list_type != GCONF_VALUE_PAIR, FALSE);
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
 
-  value_list = gconf_value_list_from_primitive_list(list_type, list, &tmp_err);
+  value_list = _gconf_value_list_from_primitive_list(list_type, list, &tmp_err);
 
   if (tmp_err)
     {
       g_propagate_error (err, tmp_err);
       return FALSE;
@@ -3473,11 +3473,11 @@ gconf_engine_set_pair    (GConfEngine* c
   g_return_val_if_fail(address_of_car != NULL, FALSE);
   g_return_val_if_fail(address_of_cdr != NULL, FALSE);
   g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
   
 
-  pair = gconf_value_pair_from_primitive_pair(car_type, cdr_type,
+  pair = _gconf_value_pair_from_primitive_pair(car_type, cdr_type,
                                               address_of_car, address_of_cdr,
                                               &tmp_err);
 
   if (tmp_err)
     {
@@ -3559,22 +3559,22 @@ gconf_handle_corba_exception(CORBA_Envir
     case CORBA_NO_EXCEPTION:
       CORBA_exception_free (ev);
       return FALSE;
     case CORBA_SYSTEM_EXCEPTION:
       if (err)
-        *err = gconf_error_new (GCONF_ERROR_NO_SERVER, _("CORBA error: %s"),
+        *err = _gconf_error_new (GCONF_ERROR_NO_SERVER, _("CORBA error: %s"),
                                 CORBA_exception_id (ev));
       CORBA_exception_free (ev);
       return TRUE;
     case CORBA_USER_EXCEPTION:
       {        
         ConfigException* ce;
 
         ce = CORBA_exception_value (ev);
 
         if (err)
-          *err = gconf_error_new (corba_errno_to_gconf_errno (ce->err_no),
+          *err = _gconf_error_new (corba_errno_to_gconf_errno (ce->err_no),
                                   "%s", ce->message);
         CORBA_exception_free (ev);
         return TRUE;
       }
     default:
Index: gconf/gconf-locale.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-locale.c,v
retrieving revision 1.9
diff -p -u -5 -r1.9 gconf-locale.c
--- gconf/gconf-locale.c	28 Sep 2001 18:31:48 -0000	1.9
+++ gconf/gconf-locale.c	4 May 2006 11:21:00 -0000
@@ -48,11 +48,11 @@ struct _Entry {
 struct _GConfLocaleCache {
   GHashTable* hash;
 };
 
 GConfLocaleCache*
-gconf_locale_cache_new (void)
+_gconf_locale_cache_new (void)
 {
   GConfLocaleCache* cache;
 
   cache = g_new(GConfLocaleCache, 1);
 
@@ -60,13 +60,13 @@ gconf_locale_cache_new (void)
 
   return cache;
 }
 
 void
-gconf_locale_cache_free (GConfLocaleCache* cache)
+_gconf_locale_cache_free (GConfLocaleCache* cache)
 {
-  gconf_locale_cache_expire (cache, 0);
+  _gconf_locale_cache_expire (cache, 0);
 
   g_assert(g_hash_table_size(cache->hash) == 0);
 
   g_hash_table_destroy(cache->hash);
 
@@ -102,21 +102,21 @@ expire_foreach(const gchar* key,
   GTime last_access = e->mod_time;
 
   /* MUST be >= so max_age of 0 will remove everything */
   if ((ed->now - last_access) >= ed->max_age)
     {
-      gconf_locale_list_unref(e->list);
+      _gconf_locale_list_unref(e->list);
       g_free(e->locale);
       g_free(e);
       return TRUE;
     }
   else
     return FALSE;
 }
 
 void
-gconf_locale_cache_expire (GConfLocaleCache* cache,
+_gconf_locale_cache_expire (GConfLocaleCache* cache,
                            guint max_age_exclusive_in_seconds)
 {
   ExpireData ed = { 0, 0 };
   ed.max_age = max_age_exclusive_in_seconds;
 
@@ -125,21 +125,21 @@ gconf_locale_cache_expire (GConfLocaleCa
   g_hash_table_foreach_remove(cache->hash, (GHRFunc)expire_foreach,
                               &ed);
 }
 
 void
-gconf_locale_list_ref (GConfLocaleList* list)
+_gconf_locale_list_ref (GConfLocaleList* list)
 {
   GConfLocaleListPrivate* priv;
 
   priv = (GConfLocaleListPrivate*) list;
 
   priv->refcount += 1;
 }
 
 void
-gconf_locale_list_unref (GConfLocaleList* list)
+_gconf_locale_list_unref (GConfLocaleList* list)
 {
   GConfLocaleListPrivate* priv;
 
   priv = (GConfLocaleListPrivate*) list;
 
@@ -153,11 +153,11 @@ gconf_locale_list_unref (GConfLocaleList
       g_free(list);
     }
 }
 
 GConfLocaleList*
-gconf_locale_cache_get_list (GConfLocaleCache* cache,
+_gconf_locale_cache_get_list (GConfLocaleCache* cache,
                              const gchar* locale)
 {
   Entry* e;
 
   if (locale == NULL)
@@ -165,22 +165,22 @@ gconf_locale_cache_get_list (GConfLocale
   
   e = g_hash_table_lookup(cache->hash, locale);
 
   if (e != NULL)
     {
-      gconf_locale_list_ref(e->list);
+      _gconf_locale_list_ref(e->list);
       return e->list;
     }
   else
     {
       gconf_locale_cache_add(cache, locale);
 
       e = g_hash_table_lookup(cache->hash, locale);
 
       g_assert(e != NULL);
 
-      gconf_locale_list_ref(e->list);
+      _gconf_locale_list_ref(e->list);
 
       return e->list;
     }
 }
 
@@ -322,17 +322,17 @@ gconf_locale_list_new (const gchar* loca
   GConfLocaleListPrivate* priv;
   
   priv = g_new(GConfLocaleListPrivate, 1);
   
   priv->refcount = 1;
-  priv->list = gconf_split_locale(locale);
+  priv->list = _gconf_split_locale(locale);
   
   return (GConfLocaleList*) priv;
 }
 
 gchar**
-gconf_split_locale               (const gchar* locale)
+_gconf_split_locale               (const gchar* locale)
 {
   gchar** vector = NULL;
   GSList* list = NULL;
   gint c_locale_defined = FALSE;
   gchar *category_memory, *orig_category_memory;
Index: gconf/gconf-backend.h
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-backend.h,v
retrieving revision 1.34
diff -p -u -5 -r1.34 gconf-backend.h
--- gconf/gconf-backend.h	30 Mar 2004 15:30:22 -0000	1.34
+++ gconf/gconf-backend.h	4 May 2006 11:21:01 -0000
@@ -154,31 +154,31 @@ struct _GConfBackend {
 };
 
 /* Address utility stuff */
 
 /* Get the backend name */
-gchar*        gconf_address_backend(const gchar* address);
+gchar*        _gconf_address_backend(const gchar* address);
 /* Get the resource name understood only by the backend */
-gchar*        gconf_address_resource(const gchar* address);
+gchar*        _gconf_address_resource(const gchar* address);
 /* Get the backend flags */
-gchar**       gconf_address_flags(const gchar* address);
+gchar**       _gconf_address_flags(const gchar* address);
 
-gchar*        gconf_backend_file(const gchar* address);
+gchar*        _gconf_backend_file(const gchar* address);
 
 /* Obtain the GConfBackend for this address, based on the first part of the 
  * address. The refcount is always incremented, and you must unref() later.
  * The same backend may be returned by multiple calls to this routine,
  * but you can assume they are different if you do the refcounting
  * right. Returns NULL if it fails.
  */
-GConfBackend* gconf_get_backend(const gchar* address, GError** err);
+GConfBackend* _gconf_get_backend(const gchar* address, GError** err);
 
-void          gconf_backend_ref(GConfBackend* backend);
-void          gconf_backend_unref(GConfBackend* backend);
+void          _gconf_backend_ref(GConfBackend* backend);
+void          _gconf_backend_unref(GConfBackend* backend);
 
-GConfSource*  gconf_backend_resolve_address (GConfBackend* backend, 
+GConfSource*  _gconf_backend_resolve_address (GConfBackend* backend, 
                                              const gchar* address,
                                              GError** err);
 
-void          gconf_blow_away_locks       (const gchar* address);
+void          _gconf_blow_away_locks       (const gchar* address);
 
 #endif
Index: gconf/gconf-backend.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-backend.c,v
retrieving revision 1.28
diff -p -u -5 -r1.28 gconf-backend.c
--- gconf/gconf-backend.c	1 Nov 2005 09:15:53 -0000	1.28
+++ gconf/gconf-backend.c	4 May 2006 11:21:01 -0000
@@ -70,11 +70,11 @@ gconf_address_valid (const char  *addres
 
   return TRUE;
 }
 
 gchar* 
-gconf_address_backend(const gchar* address)
+_gconf_address_backend(const gchar* address)
 {
   const gchar* end;
 
   g_return_val_if_fail(address != NULL, NULL);
 
@@ -93,11 +93,11 @@ gconf_address_backend(const gchar* addre
       return retval;
     }
 }
 
 gchar* 
-gconf_address_resource(const gchar* address)
+_gconf_address_resource(const gchar* address)
 {
   const gchar* start;
 
   g_return_val_if_fail(address != NULL, NULL);
 
@@ -123,11 +123,11 @@ gconf_address_resource(const gchar* addr
         }
     }
 }
 
 gchar**
-gconf_address_flags(const gchar* address)
+_gconf_address_flags(const gchar* address)
 {
   const gchar* start;
   const gchar* end;
   gchar* csv_flags;
   gchar** split_flags;
@@ -164,30 +164,30 @@ gconf_address_flags(const gchar* address
   else
     return split_flags;
 }
 
 gchar*       
-gconf_backend_file(const gchar* address)
+_gconf_backend_file(const gchar* address)
 {
   gchar* back;
   gchar* file;
   gchar* retval;
 
   g_return_val_if_fail(address != NULL, NULL);
 
-  back = gconf_address_backend(address);
+  back = _gconf_address_backend(address);
 
   if (back == NULL)
     return NULL;
 
   file = g_strconcat("gconfbackend-", back, NULL);
   
   retval = g_module_build_path(GCONF_BACKEND_DIR, file);
 
   g_free(back);
 
-  if (gconf_file_exists(retval))
+  if (_gconf_file_exists(retval))
     {
       g_free(file);
 
       return retval;
     }
@@ -203,11 +203,11 @@ gconf_backend_file(const gchar* address)
 
       retval = g_module_build_path(dir, file);
 
       g_free(dir);
       
-      if (gconf_file_exists(retval))
+      if (_gconf_file_exists(retval))
         {
           g_free(file);
           return retval;
         }
 #endif
@@ -255,11 +255,11 @@ gconf_backend_verify_vtable (GConfBacken
     { "blow_away_locks", G_STRUCT_OFFSET(GConfBackendVTable, blow_away_locks) }
   };
 
   if (!vtable)
     {
-      gconf_set_error(err,
+      _gconf_set_error(err,
 		      GCONF_ERROR_FAILED, _("Backend `%s' failed return a vtable\n"),
 		      backend_name);
       return FALSE;
     }
 
@@ -270,11 +270,11 @@ gconf_backend_verify_vtable (GConfBacken
 
   for (i = 0; i < G_N_ELEMENTS(required_vtable_functions); i++)
     {
       if (G_STRUCT_MEMBER_P(vtable_copy, required_vtable_functions[i].offset) == NULL)
 	{
-	  gconf_set_error(err,
+	  _gconf_set_error(err,
 			  GCONF_ERROR_FAILED, _("Backend `%s' missing required vtable member `%s'\n"),
 			  backend_name,
 			  required_vtable_functions[i].name);
 	  return FALSE;
 	}
@@ -282,11 +282,11 @@ gconf_backend_verify_vtable (GConfBacken
 
   return TRUE;
 }
 
 GConfBackend* 
-gconf_get_backend(const gchar* address, GError** err)
+_gconf_get_backend(const gchar* address, GError** err)
 {
   GConfBackend* backend;
   gchar* name;
   gchar* why_invalid;
 
@@ -297,38 +297,38 @@ gconf_get_backend(const gchar* address, 
 
   why_invalid = NULL;
   if (!gconf_address_valid (address, &why_invalid))
     {
       g_assert (why_invalid != NULL);
-      gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS, _("Bad address `%s': %s"),
+      _gconf_set_error (err, GCONF_ERROR_BAD_ADDRESS, _("Bad address `%s': %s"),
 		       address, why_invalid);
       g_free (why_invalid);
       return NULL;
     }
 
-  name = gconf_address_backend(address);
+  name = _gconf_address_backend(address);
       
   if (name == NULL)
     {
-      gconf_set_error(err, GCONF_ERROR_BAD_ADDRESS, _("Bad address `%s'"), address);
+      _gconf_set_error(err, GCONF_ERROR_BAD_ADDRESS, _("Bad address `%s'"), address);
       return NULL;
     }
 
   backend = g_hash_table_lookup(loaded_backends, name);
 
   if (backend != NULL)
     {
       /* Returning a "copy" */
-      gconf_backend_ref(backend);
+      _gconf_backend_ref(backend);
       g_free(name);
       return backend;
     }
   else
     {
       gchar* file;
           
-      file = gconf_backend_file(address);
+      file = _gconf_backend_file(address);
           
       if (file != NULL)
         {
           GModule* module;
           GConfBackendVTable* (*get_vtable)(void);
@@ -340,22 +340,22 @@ gconf_get_backend(const gchar* address, 
               
           g_free(file);
           
           if (module == NULL)
             {
-              gconf_set_error(err,
+              _gconf_set_error(err,
                               GCONF_ERROR_FAILED, _("Error opening module `%s': %s\n"),
                               name, g_module_error());
               g_free(name);
               return NULL;
             }
 
           if (!g_module_symbol(module, 
                                "gconf_backend_get_vtable", 
                                (gpointer*)&get_vtable))
             {
-              gconf_set_error(err,
+              _gconf_set_error(err,
                               GCONF_ERROR_FAILED, _("Error initializing module `%s': %s\n"),
                               name, g_module_error());
               g_module_close(module);
               g_free(name);
               return NULL;
@@ -376,33 +376,33 @@ gconf_get_backend(const gchar* address, 
           backend->name = name;
 
           g_hash_table_insert(loaded_backends, (gchar*)backend->name, backend);
           
           /* Returning a "copy" */
-          gconf_backend_ref(backend);
+          _gconf_backend_ref(backend);
 
           return backend;
         }
       else
         {
-          gconf_set_error(err, GCONF_ERROR_FAILED,
+          _gconf_set_error(err, GCONF_ERROR_FAILED,
                           _("Couldn't locate backend module for `%s'"), address);
           return NULL;
         }
     }
 }
 
 void          
-gconf_backend_ref(GConfBackend* backend)
+_gconf_backend_ref(GConfBackend* backend)
 {
   g_return_if_fail(backend != NULL);
 
   backend->refcount += 1;
 }
 
 void          
-gconf_backend_unref(GConfBackend* backend)
+_gconf_backend_unref(GConfBackend* backend)
 {
   g_return_if_fail(backend != NULL);
   g_return_if_fail(backend->refcount > 0);
 
   if (backend->refcount > 1)
@@ -435,11 +435,11 @@ gconf_backend_unref(GConfBackend* backen
 /*
  * Backend vtable wrappers
  */
 
 GConfSource*  
-gconf_backend_resolve_address (GConfBackend* backend, 
+_gconf_backend_resolve_address (GConfBackend* backend, 
                                const gchar* address,
                                GError** err)
 {
   gchar** flags;
   gchar** iter;
@@ -448,11 +448,11 @@ gconf_backend_resolve_address (GConfBack
   retval = (*backend->vtable.resolve_address)(address, err);
 
   if (retval == NULL)
     return NULL;
 
-  flags = gconf_address_flags(address);
+  flags = _gconf_address_flags(address);
 
   if (flags == NULL)
     return retval;
 
   /* FIXME this is now already done in the XML backend,
@@ -478,15 +478,15 @@ gconf_backend_resolve_address (GConfBack
 
   return retval;
 }
 
 void
-gconf_blow_away_locks (const gchar* address)
+_gconf_blow_away_locks (const gchar* address)
 {
   GConfBackend* backend;
 
-  backend = gconf_get_backend (address, NULL);
+  backend = _gconf_get_backend (address, NULL);
 
   if (backend != NULL)
     {
       (*backend->vtable.blow_away_locks) (address);
     }
Index: gconf/gconf-error.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-error.c,v
retrieving revision 1.14
diff -p -u -5 -r1.14 gconf-error.c
--- gconf/gconf-error.c	22 Oct 2003 21:03:08 -0000	1.14
+++ gconf/gconf-error.c	4 May 2006 11:21:01 -0000
@@ -60,11 +60,11 @@ gconf_error_quark (void)
 
   return err_q;
 }
 
 static GError* 
-gconf_error_new_valist(GConfError en, const gchar* fmt, va_list args)
+_gconf_error_new_valist(GConfError en, const gchar* fmt, va_list args)
 {
   GError *err;
   gchar* orig;
   
   orig = g_strdup_vprintf(fmt, args);
@@ -77,24 +77,24 @@ gconf_error_new_valist(GConfError en, co
   
   return err;
 }
 
 GError*
-gconf_error_new(GConfError en, const gchar* fmt, ...)
+_gconf_error_new(GConfError en, const gchar* fmt, ...)
 {
   GError* err;
   va_list args;
   
   va_start (args, fmt);
-  err = gconf_error_new_valist(en, fmt, args);
+  err = _gconf_error_new_valist(en, fmt, args);
   va_end (args);
 
   return err;
 }
 
 void
-gconf_set_error      (GError** err, GConfError en, const gchar* fmt, ...)
+_gconf_set_error      (GError** err, GConfError en, const gchar* fmt, ...)
 {
   GError* obj;
   va_list args;
 
   if (err == NULL)
@@ -105,19 +105,19 @@ gconf_set_error      (GError** err, GCon
    * error
    */
   g_return_if_fail(*err == NULL);
   
   va_start (args, fmt);
-  obj = gconf_error_new_valist(en, fmt, args);
+  obj = _gconf_error_new_valist(en, fmt, args);
   va_end (args);
 
   *err = obj;
 }
 
 /* This function should die. */
 GError*
-gconf_compose_errors (GError* err1, GError* err2)
+_gconf_compose_errors (GError* err1, GError* err2)
 {
   if (err1 == NULL && err2 == NULL)
     return NULL;
   else if (err1 == NULL)
     return g_error_copy(err2);
Index: gconf/gconf-sanity-check.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-sanity-check.c,v
retrieving revision 1.11
diff -p -u -5 -r1.11 gconf-sanity-check.c
--- gconf/gconf-sanity-check.c	9 Sep 2005 22:15:45 -0000	1.11
+++ gconf/gconf-sanity-check.c	4 May 2006 11:21:01 -0000
@@ -127,11 +127,11 @@ check_file_locking (void)
 
   retval = FALSE;
   testfile = NULL;
   fd = -1;
   
-  if (gconf_use_local_locks ())
+  if (_gconf_use_local_locks ())
     {
       GError *err;
 
       err = NULL;
       fd = g_file_open_tmp ("gconf-test-locking-file-XXXXXX",
@@ -216,20 +216,20 @@ check_gconf (gboolean display_errors)
   
   /* If gconfd is already running, it's expected that we won't be able
    * to get locks etc., and everything is already fine.
    * Plus we can skip the slow sanity checks like resolve_address.
    */
-  if (gconf_ping_daemon ())
+  if (_gconf_ping_daemon ())
     {
       retval = TRUE;
       goto out;
     }
   
   conffile = g_build_filename (GCONF_CONFDIR, "path", NULL);
 
   error = NULL;
-  addresses = gconf_load_source_path (conffile, &error);
+  addresses = _gconf_load_source_path (conffile, &error);
 
   if (addresses == NULL)
     {
       if (display_errors)
         show_fatal_error_dialog (_("Please contact your system administrator to resolve the following problem:\n"
@@ -251,11 +251,11 @@ check_gconf (gboolean display_errors)
       const char *address;
 
       address = tmp->data;
       
       error = NULL;      
-      source = gconf_resolve_address (address, &error);
+      source = _gconf_resolve_address (address, &error);
 
       if (error)
         {
           if (display_errors)
             show_fatal_error_dialog (_("Please contact your system administrator to resolve the following problem:\n"
@@ -263,11 +263,11 @@ check_gconf (gboolean display_errors)
                                      address, conffile, error->message);
           g_error_free (error);
           goto out;
         }
 
-      gconf_source_free (source);
+      _gconf_source_free (source);
       
       g_free (tmp->data);
       
       tmp = tmp->next;
     }
@@ -371,11 +371,11 @@ offer_delete_locks (void)
       GSList* tmp;
       char *conffile;
       
       conffile = g_build_filename (GCONF_CONFDIR, "path", NULL);
       
-      addresses = gconf_load_source_path (conffile, NULL);
+      addresses = _gconf_load_source_path (conffile, NULL);
 
       g_free (conffile);
       
       if (addresses == NULL)
         g_printerr ("Failed to load addresses to delete locks\n");
@@ -385,20 +385,20 @@ offer_delete_locks (void)
         {
           const char *address;
           
           address = tmp->data;
           
-          gconf_blow_away_locks (address);
+          _gconf_blow_away_locks (address);
 
           g_free (tmp->data);
           
           tmp = tmp->next;
         }
 
       g_slist_free (addresses);
       
-      gconf_daemon_blow_away_locks ();
+      _gconf_daemon_blow_away_locks ();
 
       return TRUE;
     }
 
   return FALSE;
Index: gconf/gconf-sources.h
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-sources.h,v
retrieving revision 1.24
diff -p -u -5 -r1.24 gconf-sources.h
--- gconf/gconf-sources.h	30 Mar 2004 15:19:08 -0000	1.24
+++ gconf/gconf-sources.h	4 May 2006 11:21:02 -0000
@@ -53,14 +53,14 @@ typedef enum {
 
 typedef void (* GConfSourceNotifyFunc) (GConfSource *source,
 					const gchar *location,
 					gpointer     user_data);
 
-GConfSource*  gconf_resolve_address         (const gchar* address,
+GConfSource*  _gconf_resolve_address         (const gchar* address,
                                              GError** err);
 
-void          gconf_source_free          (GConfSource* source);
+void          _gconf_source_free          (GConfSource* source);
 
 /* This is the actual thing we want to talk to, the stack of sources */
 typedef struct _GConfSources GConfSources;
 
 struct _GConfSources {
@@ -75,79 +75,79 @@ typedef struct
 
 
 /* Even on error, this gives you an empty source list, i.e.  never
    returns NULL but may set the error if some addresses weren't
    resolved and may contain no sources.  */
-GConfSources* gconf_sources_new_from_addresses (GSList* addresses,
+GConfSources* _gconf_sources_new_from_addresses (GSList* addresses,
                                                 GError   **err);
-GConfSources* gconf_sources_new_from_source    (GConfSource   *source);
-void          gconf_sources_free               (GConfSources  *sources);
-void          gconf_sources_clear_cache        (GConfSources  *sources);
-GConfValue*   gconf_sources_query_value        (GConfSources  *sources,
+GConfSources* _gconf_sources_new_from_source    (GConfSource   *source);
+void          _gconf_sources_free               (GConfSources  *sources);
+void          _gconf_sources_clear_cache        (GConfSources  *sources);
+GConfValue*   _gconf_sources_query_value        (GConfSources  *sources,
                                                 const gchar   *key,
                                                 const gchar  **locales,
                                                 gboolean       use_schema_default,
                                                 gboolean      *value_is_default,
                                                 gboolean      *value_is_writable,
                                                 gchar        **schema_name,
                                                 GError   **err);
-void          gconf_sources_set_value          (GConfSources  *sources,
+void          _gconf_sources_set_value          (GConfSources  *sources,
                                                 const gchar   *key,
                                                 const GConfValue *value,
 						GConfSources **modified_sources,
                                                 GError   **err);
-void          gconf_sources_unset_value        (GConfSources  *sources,
+void          _gconf_sources_unset_value        (GConfSources  *sources,
                                                 const gchar   *key,
                                                 const gchar   *locale,
 						GConfSources **modified_sources,
                                                 GError   **err);
-void          gconf_sources_recursive_unset    (GConfSources  *sources,
+void          _gconf_sources_recursive_unset    (GConfSources  *sources,
                                                 const gchar   *key,
                                                 const gchar   *locale,
                                                 GConfUnsetFlags flags,
                                                 GSList      **notifies,
                                                 GError      **err);
-GSList*       gconf_sources_all_entries        (GConfSources  *sources,
+GSList*       _gconf_sources_all_entries        (GConfSources  *sources,
                                                 const gchar   *dir,
                                                 const gchar  **locales,
                                                 GError   **err);
-GSList*       gconf_sources_all_dirs           (GConfSources  *sources,
+GSList*       _gconf_sources_all_dirs           (GConfSources  *sources,
                                                 const gchar   *dir,
                                                 GError   **err);
-gboolean      gconf_sources_dir_exists         (GConfSources  *sources,
+gboolean      _gconf_sources_dir_exists         (GConfSources  *sources,
                                                 const gchar   *dir,
                                                 GError   **err);
-void          gconf_sources_remove_dir         (GConfSources  *sources,
+void          _gconf_sources_remove_dir         (GConfSources  *sources,
                                                 const gchar   *dir,
                                                 GError   **err);
-void          gconf_sources_set_schema         (GConfSources  *sources,
+void          _gconf_sources_set_schema         (GConfSources  *sources,
                                                 const gchar   *key,
                                                 const gchar   *schema_key,
                                                 GError   **err);
-gboolean      gconf_sources_sync_all           (GConfSources  *sources,
+gboolean      _gconf_sources_sync_all           (GConfSources  *sources,
                                                 GError   **err);
 
 
-GConfMetaInfo*gconf_sources_query_metainfo     (GConfSources* sources,
+GConfMetaInfo*_gconf_sources_query_metainfo     (GConfSources* sources,
                                                 const gchar* key,
                                                 GError** err);
 
-GConfValue*   gconf_sources_query_default_value(GConfSources* sources,
+GConfValue*   _gconf_sources_query_default_value(GConfSources* sources,
                                                 const gchar* key,
                                                 const gchar** locales,
                                                 gboolean* is_writable,
                                                 GError** err);
 
-void          gconf_sources_set_notify_func    (GConfSources          *sources,
+void          _gconf_sources_set_notify_func    (GConfSources          *sources,
 					        GConfSourceNotifyFunc  notify_func,
 					        gpointer               user_data);
-void          gconf_sources_add_listener       (GConfSources          *sources,
+void          _gconf_sources_add_listener       (GConfSources          *sources,
 						guint                  id,
 					        const gchar           *location);
-void          gconf_sources_remove_listener    (GConfSources          *sources,
+void          _gconf_sources_remove_listener    (GConfSources          *sources,
 						guint                  id);
 
-gboolean      gconf_sources_is_affected        (GConfSources *sources,
+gboolean      _gconf_sources_is_affected        (GConfSources *sources,
 						GConfSource  *modified_src,
 						const char   *key);
 
 #endif
Index: gconf/gconf-client.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-client.c,v
retrieving revision 1.68
diff -p -u -5 -r1.68 gconf-client.c
--- gconf/gconf-client.c	5 Jan 2006 20:19:38 -0000	1.68
+++ gconf/gconf-client.c	4 May 2006 11:21:02 -0000
@@ -101,12 +101,12 @@ static void listener_destroy(Listener* l
 
 /*
  * GConfClient proper
  */
 
-#define PUSH_USE_ENGINE(client) do { if ((client)->engine) gconf_engine_push_owner_usage ((client)->engine, client); } while (0)
-#define POP_USE_ENGINE(client) do { if ((client)->engine) gconf_engine_pop_owner_usage ((client)->engine, client); } while (0)
+#define PUSH_USE_ENGINE(client) do { if ((client)->engine) _gconf_engine_push_owner_usage ((client)->engine, client); } while (0)
+#define POP_USE_ENGINE(client) do { if ((client)->engine) _gconf_engine_pop_owner_usage ((client)->engine, client); } while (0)
 
 enum {
   VALUE_CHANGED,
   UNRETURNED_ERROR,
   ERROR,
@@ -271,16 +271,16 @@ set_engine (GConfClient *client,
   
   if (engine)
     {
       gconf_engine_ref (engine);
 
-      gconf_engine_set_owner (engine, client);
+      _gconf_engine_set_owner (engine, client);
     }
   
   if (client->engine)
     {
-      gconf_engine_set_owner (client->engine, NULL);
+      _gconf_engine_set_owner (client->engine, NULL);
       
       gconf_engine_unref (client->engine);
     }
   
   client->engine = engine;  
@@ -1023,11 +1023,11 @@ gconf_client_recursive_unset (GConfClien
   GError* error = NULL;
 
   trace ("Unsetting '%s'\n", key);
   
   PUSH_USE_ENGINE (client);
-  gconf_engine_recursive_unset(client->engine, key, flags, &error);
+  _gconf_engine_recursive_unset(client->engine, key, flags, &error);
   POP_USE_ENGINE (client);
   
   handle_error(client, error, err);
 
   if (error != NULL)
@@ -1191,14 +1191,14 @@ gconf_client_key_is_writable (GConfClien
 static gboolean
 check_type(const gchar* key, GConfValue* val, GConfValueType t, GError** err)
 {
   if (val->type != t)
     {
-      gconf_set_error(err, GCONF_ERROR_TYPE_MISMATCH,
+      _gconf_set_error(err, GCONF_ERROR_TYPE_MISMATCH,
                       _("Expected `%s' got `%s' for key %s"),
-                      gconf_value_type_to_string(t),
-                      gconf_value_type_to_string(val->type),
+                      _gconf_value_type_to_string(t),
+                      _gconf_value_type_to_string(val->type),
                       key);
       return FALSE;
     }
   else
     return TRUE;
@@ -1235,11 +1235,11 @@ get (GConfClient *client,
 
   /* Check the GConfEngine */
   trace ("Doing remote query for %s\n", key);
   PUSH_USE_ENGINE (client);
   entry = gconf_engine_get_entry (client->engine, key,
-                                  gconf_current_locale(),
+                                  _gconf_current_locale(),
                                   TRUE /* always use default here */,
                                   error);
   POP_USE_ENGINE (client);
   
   if (*error != NULL)
@@ -1489,11 +1489,11 @@ gconf_client_get_string(GConfClient* cli
       gchar* retval = NULL;
 
       g_assert(error == NULL);
       
       if (check_type (key, val, GCONF_VALUE_STRING, &error))
-        retval = gconf_value_steal_string (val);
+        retval = _gconf_value_steal_string (val);
       else
         handle_error (client, error, err);
       
       gconf_value_free (val);
 
@@ -1559,11 +1559,11 @@ gconf_client_get_schema  (GConfClient* c
       GConfSchema* retval = NULL;
 
       g_assert(error == NULL);
       
       if (check_type (key, val, GCONF_VALUE_SCHEMA, &error))
-        retval = gconf_value_steal_schema (val);
+        retval = _gconf_value_steal_schema (val);
       else
         handle_error (client, error, err);
       
       gconf_value_free (val);
 
@@ -1593,11 +1593,11 @@ gconf_client_get_list    (GConfClient* c
       GSList* retval;
 
       g_assert (error == NULL);
 
       /* This function checks the type and destroys "val" */
-      retval = gconf_value_list_to_primitive_list_destructive (val, list_type, &error);
+      retval = _gconf_value_list_to_primitive_list_destructive (val, list_type, &error);
 
       if (error != NULL)
         {
           g_assert (retval == NULL);
           handle_error (client, error, err);
@@ -1630,11 +1630,11 @@ gconf_client_get_pair    (GConfClient* c
   if (val != NULL)
     {
       g_assert(error == NULL);
 
       /* This function checks the type and destroys "val" */
-      if (gconf_value_pair_to_primitive_pair_destructive (val, car_type, cdr_type,
+      if (_gconf_value_pair_to_primitive_pair_destructive (val, car_type, cdr_type,
                                                           car_retloc, cdr_retloc,
                                                           &error))
         {
           g_assert (error == NULL);
           return TRUE;
Index: gconf/gconf-database.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-database.c,v
retrieving revision 1.39
diff -p -u -5 -r1.39 gconf-database.c
--- gconf/gconf-database.c	21 Apr 2004 17:46:04 -0000	1.39
+++ gconf/gconf-database.c	4 May 2006 11:21:02 -0000
@@ -90,11 +90,11 @@ impl_ConfigDatabase_lookup_with_locale(P
   GConfLocaleList* locale_list;
   gboolean is_default = FALSE;
   gboolean is_writable = TRUE;
 
   if (gconfd_check_in_shutdown (ev))
-    return gconf_invalid_corba_value ();
+    return _gconf_invalid_corba_value ();
   
   locale_list = locale_cache_lookup(locale);
   
   val = gconf_database_query_value(db, key, locale_list->list,
                                    use_schema_default,
@@ -104,15 +104,15 @@ impl_ConfigDatabase_lookup_with_locale(P
                                    &error);
 
   *value_is_default = is_default;
   *value_is_writable = is_writable;
   
-  gconf_locale_list_unref(locale_list);
+  _gconf_locale_list_unref(locale_list);
   
   if (val != NULL)
     {
-      ConfigValue* cval = gconf_corba_value_from_gconf_value(val);
+      ConfigValue* cval = _gconf_corba_value_from_gconf_value(val);
 
       gconf_value_free(val);
 
       g_return_val_if_fail(error == NULL, cval);
       
@@ -120,21 +120,21 @@ impl_ConfigDatabase_lookup_with_locale(P
     }
   else
     {
       gconf_set_exception(&error, ev);
 
-      return gconf_invalid_corba_value ();
+      return _gconf_invalid_corba_value ();
     }
 }
 
 static ConfigValue *
 impl_ConfigDatabase_lookup(PortableServer_Servant servant,
                            const CORBA_char * key,
                            CORBA_Environment * ev)
 {
   if (gconfd_check_in_shutdown (ev))
-    return gconf_invalid_corba_value ();
+    return _gconf_invalid_corba_value ();
   
   return impl_ConfigDatabase_lookup_with_locale (servant, key,
                                                  NULL, TRUE, NULL,
                                                  NULL, ev);
 }
@@ -149,24 +149,24 @@ impl_ConfigDatabase_lookup_default_value
   GConfValue* val;
   GError* error = NULL;
   GConfLocaleList* locale_list;  
 
   if (gconfd_check_in_shutdown (ev))
-    return gconf_invalid_corba_value ();
+    return _gconf_invalid_corba_value ();
   
   locale_list = locale_cache_lookup(locale);
   
   val = gconf_database_query_default_value(db, key,
                                            locale_list->list,
                                            NULL,
                                            &error);
 
-  gconf_locale_list_unref(locale_list);
+  _gconf_locale_list_unref(locale_list);
   
   if (val != NULL)
     {
-      ConfigValue* cval = gconf_corba_value_from_gconf_value(val);
+      ConfigValue* cval = _gconf_corba_value_from_gconf_value(val);
 
       gconf_value_free(val);
 
       g_return_val_if_fail(error == NULL, cval);
       
@@ -174,11 +174,11 @@ impl_ConfigDatabase_lookup_default_value
     }
   else
     {
       gconf_set_exception(&error, ev);
 
-      return gconf_invalid_corba_value ();
+      return _gconf_invalid_corba_value ();
     }
 }
 
 static void
 impl_ConfigDatabase_batch_lookup(PortableServer_Servant servant,
@@ -210,11 +210,11 @@ impl_ConfigDatabase_set(PortableServer_S
     {
       gconf_log(GCL_ERR, _("Received invalid value in set request"));
       return;
     }
 
-  val = gconf_value_from_corba_value(value);
+  val = _gconf_value_from_corba_value(value);
 
   if (val == NULL)
     {
       gconf_log(GCL_ERR, _("Couldn't make sense of CORBA value received in set request for key `%s'"), key);
       return;
@@ -337,11 +337,11 @@ impl_ConfigDatabase_all_entries(Portable
   
   locale_list = locale_cache_lookup(locale);
   
   pairs = gconf_database_all_entries(db, dir, locale_list->list, &error);
   
-  gconf_locale_list_unref(locale_list);
+  _gconf_locale_list_unref(locale_list);
 
   if (error != NULL)
     {
       gconf_set_exception(&error, ev);
       return;
@@ -382,11 +382,11 @@ impl_ConfigDatabase_all_entries(Portable
 
       g_assert(p != NULL);
       g_assert(p->key != NULL);
 
       (*keys)->_buffer[i] = CORBA_string_dup(p->key);
-      gconf_fill_corba_value_from_gconf_value (gconf_entry_get_value (p),
+      _gconf_fill_corba_value_from_gconf_value (gconf_entry_get_value (p),
                                                &((*values)->_buffer[i]));
       (*is_defaults)->_buffer[i] = gconf_entry_get_is_default(p);
       (*is_writables)->_buffer[i] = gconf_entry_get_is_writable(p);
       
       gconf_entry_free(p);
@@ -543,11 +543,11 @@ impl_ConfigDatabase2_lookup_with_schema_
   gboolean is_writable = TRUE;
   char *s;
   ConfigValue* cval;
   
   if (gconfd_check_in_shutdown (ev))
-    return gconf_invalid_corba_value ();
+    return _gconf_invalid_corba_value ();
   
   locale_list = locale_cache_lookup(locale);
 
   s = NULL;
   val = gconf_database_query_value(db, key, locale_list->list,
@@ -565,21 +565,21 @@ impl_ConfigDatabase2_lookup_with_schema_
   else
     *schema_name = CORBA_string_dup ("");
 
   g_free (s);
   
-  gconf_locale_list_unref(locale_list);
+  _gconf_locale_list_unref(locale_list);
   
   if (val != NULL)
     {
-      cval = gconf_corba_value_from_gconf_value(val);
+      cval = _gconf_corba_value_from_gconf_value(val);
       gconf_value_free(val);
       g_return_val_if_fail(error == NULL, cval);
     }
   else
     {
-      cval = gconf_invalid_corba_value ();
+      cval = _gconf_invalid_corba_value ();
     }
 
   gconf_log (GCL_DEBUG, "In lookup_with_schema_name returning schema name '%s' error '%s'",
              *schema_name, error ? error->message : "none");
   
@@ -615,11 +615,11 @@ impl_ConfigDatabase2_all_entries_with_sc
   
   locale_list = locale_cache_lookup(locale);
   
   pairs = gconf_database_all_entries(db, dir, locale_list->list, &error);
   
-  gconf_locale_list_unref(locale_list);
+  _gconf_locale_list_unref(locale_list);
 
   if (error != NULL)
     {
       gconf_set_exception(&error, ev);
       return;
@@ -666,11 +666,11 @@ impl_ConfigDatabase2_all_entries_with_sc
 
       g_assert(p != NULL);
       g_assert(p->key != NULL);
 
       (*keys)->_buffer[i] = CORBA_string_dup (p->key);
-      gconf_fill_corba_value_from_gconf_value (gconf_entry_get_value (p),
+      _gconf_fill_corba_value_from_gconf_value (gconf_entry_get_value (p),
                                                &((*values)->_buffer[i]));
       (*schema_names)->_buffer[i] = CORBA_string_dup (gconf_entry_get_schema_name (p));
       if ((*schema_names)->_buffer[i] == NULL)
         (*schema_names)->_buffer[i] = CORBA_string_dup ("");
       (*is_defaults)->_buffer[i] = gconf_entry_get_is_default(p);
@@ -811,11 +811,11 @@ gconf_database_new (GConfSources  *sourc
 
   db->listeners = gconf_listeners_new();
 
   db->sources = sources;
 
-  gconf_sources_set_notify_func (db->sources,
+  _gconf_sources_set_notify_func (db->sources,
 				 (GConfSourceNotifyFunc) source_notify_cb,
 				 db);
 
   db->last_access = time(NULL);
 
@@ -875,11 +875,11 @@ gconf_database_free (GConfDatabase *db)
 
       if (need_sync)
         gconf_database_really_sync(db);
       
       gconf_listeners_free(db->listeners);
-      gconf_sources_free(db->sources);
+      _gconf_sources_free(db->sources);
     }
 
   g_free (db->persistent_name);
   
   g_free (db);
@@ -1019,11 +1019,11 @@ source_notify_cb (GConfSource   *source,
 {
   g_return_if_fail (source != NULL);
   g_return_if_fail (location != NULL);
   g_return_if_fail (db != NULL);
 
-  if (gconf_sources_is_affected (db->sources, source, location))
+  if (_gconf_sources_is_affected (db->sources, source, location))
     {
       GConfValue  *value;
       ConfigValue *cvalue;
       GError      *error;
       gboolean     is_default;
@@ -1049,11 +1049,11 @@ source_notify_cb (GConfSource   *source,
 		     error->message);
 	  g_error_free (error);
 	  return;
 	}
 
-      cvalue = gconf_corba_value_from_gconf_value (value);
+      cvalue = _gconf_corba_value_from_gconf_value (value);
       gconf_database_notify_listeners (db,
 				       NULL,
 				       location,
 				       cvalue,
 				       is_default,
@@ -1082,11 +1082,11 @@ gconf_database_readd_listener   (GConfDa
   l = listener_new (who, name);
 
   cnxn = gconf_listeners_add (db->listeners, where, l,
                               (GFreeFunc)listener_destroy);
 
-  gconf_sources_add_listener (db->sources, cnxn, where);
+  _gconf_sources_add_listener (db->sources, cnxn, where);
 
   if (l->name == NULL)
     l->name = g_strdup_printf ("%u", cnxn);
   
   gconf_log (GCL_DEBUG, "Added listener %s (%u)", l->name, cnxn);
@@ -1167,11 +1167,11 @@ gconf_database_remove_listener (GConfDat
       gconf_log (GCL_WARNING, _("Failed to log removal of listener to logfile (most likely harmless, may result in a notification weirdly reappearing): %s"),
                  err->message);
       g_error_free (err);
     }
   
-  gconf_sources_remove_listener (db->sources, cnxn);
+  _gconf_sources_remove_listener (db->sources, cnxn);
 
   /* calls destroy notify */
   gconf_listeners_remove (db->listeners, cnxn);
 }
 
@@ -1285,11 +1285,11 @@ gconf_database_query_value (GConfDatabas
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   g_assert(db->listeners != NULL);
   
   db->last_access = time(NULL);
   
-  val = gconf_sources_query_value(db->sources, key, locales,
+  val = _gconf_sources_query_value(db->sources, key, locales,
                                   use_schema_default,
                                   value_is_default,
                                   value_is_writable,
                                   schema_name,
                                   err);
@@ -1313,11 +1313,11 @@ gconf_database_query_default_value (GCon
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
   g_assert(db->listeners != NULL);
   
   db->last_access = time(NULL);
 
-  return gconf_sources_query_default_value(db->sources, key, locales,
+  return _gconf_sources_query_default_value(db->sources, key, locales,
                                            is_writable,
                                            err);
 }
 
 void
@@ -1338,11 +1338,11 @@ gconf_database_set   (GConfDatabase     
 #if 0
   /* this really churns the logfile, so we avoid it */
   gconf_log(GCL_DEBUG, "Received request to set key `%s'", key);
 #endif
   
-  gconf_sources_set_value(db->sources, key, value, &modified_sources, &error);
+  _gconf_sources_set_value(db->sources, key, value, &modified_sources, &error);
 
   if (error)
     {
       g_assert (modified_sources == NULL);
 
@@ -1386,11 +1386,11 @@ gconf_database_unset (GConfDatabase     
   
   db->last_access = time(NULL);
   
   gconf_log(GCL_DEBUG, "Received request to unset key `%s'", key);
 
-  gconf_sources_unset_value(db->sources, key, locale, &modified_sources, &error);
+  _gconf_sources_unset_value(db->sources, key, locale, &modified_sources, &error);
 
   if (error != NULL)
     {
       g_assert (modified_sources == NULL);
 
@@ -1426,16 +1426,16 @@ gconf_database_unset (GConfDatabase     
         gconf_log(GCL_ERR, _("Error getting default value for `%s': %s"),
                   key, (*err)->message);
 
       if (def_value != NULL)
         {
-          val = gconf_corba_value_from_gconf_value(def_value);
+          val = _gconf_corba_value_from_gconf_value(def_value);
           gconf_value_free(def_value);
         }
       else
         {
-          val = gconf_invalid_corba_value ();
+          val = _gconf_invalid_corba_value ();
         }
           
       gconf_database_schedule_sync(db);
 
       gconf_database_notify_listeners(db,
@@ -1468,11 +1468,11 @@ gconf_database_recursive_unset (GConfDat
   db->last_access = time (NULL);
   
   gconf_log (GCL_DEBUG, "Received request to recursively unset key \"%s\"", key);
 
   notifies = NULL;
-  gconf_sources_recursive_unset (db->sources, key, locale,
+  _gconf_sources_recursive_unset (db->sources, key, locale,
                                  flags, &notifies, &error);
 
   /* We return the error but go ahead and finish the unset.
    * We're just returning the first error seen during the
    * unset process.
@@ -1518,16 +1518,16 @@ gconf_database_recursive_unset (GConfDat
 	  error = NULL;
 	}
       
       if (new_value != NULL)
         {
-          val = gconf_corba_value_from_gconf_value (new_value);
+          val = _gconf_corba_value_from_gconf_value (new_value);
           gconf_value_free (new_value);
         }
       else
         {
-          val = gconf_invalid_corba_value ();
+          val = _gconf_invalid_corba_value ();
         }
           
       gconf_database_schedule_sync (db);
 
       gconf_database_notify_listeners (db,
@@ -1561,11 +1561,11 @@ gconf_database_dir_exists  (GConfDatabas
   
   db->last_access = time(NULL);
   
   gconf_log(GCL_DEBUG, "Received dir_exists request for `%s'", dir);
   
-  ret = gconf_sources_dir_exists(db->sources, dir, err);
+  ret = _gconf_sources_dir_exists(db->sources, dir, err);
   
   if (err && *err != NULL)
     {
       gconf_log(GCL_ERR, _("Error checking existence of `%s': %s"),
                  dir, (*err)->message);
@@ -1585,11 +1585,11 @@ gconf_database_remove_dir  (GConfDatabas
   
   db->last_access = time(NULL);
   
   gconf_log (GCL_DEBUG, "Received request to remove directory \"%s\"", dir);
   
-  gconf_sources_remove_dir(db->sources, dir, err);
+  _gconf_sources_remove_dir(db->sources, dir, err);
 
   if (err && *err != NULL)
     {
       gconf_log (GCL_ERR, _("Error removing directory \"%s\": %s"),
                  dir, (*err)->message);
@@ -1612,11 +1612,11 @@ gconf_database_all_entries (GConfDatabas
   
   g_assert(db->listeners != NULL);
   
   db->last_access = time(NULL);
   
-  entries = gconf_sources_all_entries(db->sources, dir, locales, err);
+  entries = _gconf_sources_all_entries(db->sources, dir, locales, err);
 
   if (err && *err != NULL)
     {
       gconf_log(GCL_ERR, _("Failed to get all entries in `%s': %s"),
                  dir, (*err)->message);
@@ -1638,11 +1638,11 @@ gconf_database_all_dirs (GConfDatabase  
   
   db->last_access = time(NULL);
     
   gconf_log (GCL_DEBUG, "Received request to list all subdirs in `%s'", dir);
 
-  subdirs = gconf_sources_all_dirs (db->sources, dir, err);
+  subdirs = _gconf_sources_all_dirs (db->sources, dir, err);
 
   if (err && *err != NULL)
     {
       gconf_log (GCL_ERR, _("Error listing dirs in `%s': %s"),
                  dir, (*err)->message);
@@ -1659,11 +1659,11 @@ gconf_database_set_schema (GConfDatabase
   g_return_if_fail (err == NULL || *err == NULL);
   g_assert (db->listeners != NULL);
   
   db->last_access = time (NULL);
   
-  gconf_sources_set_schema (db->sources, key, schema_key, err);
+  _gconf_sources_set_schema (db->sources, key, schema_key, err);
 
   if (err && *err != NULL)
     {
       gconf_log (GCL_ERR, _("Error setting schema for `%s': %s"),
                 key, (*err)->message);
@@ -1704,22 +1704,22 @@ gconf_database_synchronous_sync (GConfDa
       db->sync_idle = 0;
     }
 
   db->last_access = time(NULL);
   
-  return gconf_sources_sync_all(db->sources, err);
+  return _gconf_sources_sync_all(db->sources, err);
 }
 
 void
 gconf_database_clear_cache (GConfDatabase  *db,
                             GError    **err)
 {
   g_assert(db->listeners != NULL);
 
   db->last_access = time(NULL);
 
-  gconf_sources_clear_cache(db->sources);
+  _gconf_sources_clear_cache(db->sources);
 }
 
 const gchar *
 gconf_database_get_persistent_name (GConfDatabase *db)
 {
@@ -1787,22 +1787,22 @@ listener_save_foreach (const gchar* loca
 
   g_string_append (fd->str, s);
 
   g_free (s);
 
-  s = gconf_quote_string (location);
+  s = _gconf_quote_string (location);
   g_string_append (fd->str, s);
   g_free (s);
   g_string_append_c (fd->str, ' ');
   
-  orb = gconf_orb_get ();
+  orb = _gconf_orb_get ();
 
   CORBA_exception_init (&ev);
   
   ior = CORBA_ORB_object_to_string(orb, l->obj, &ev);
 
-  s = gconf_quote_string (ior);
+  s = _gconf_quote_string (ior);
 
   g_string_append (fd->str, s);
 
   g_free (s);
   
@@ -1819,15 +1819,15 @@ gconf_database_log_listeners_to_string (
   struct ForeachData fd;
 
   fd.str = str;
   
   if (is_default)
-    fd.db_name = gconf_quote_string ("def");
+    fd.db_name = _gconf_quote_string ("def");
   else
     {
       fd.db_name =
-        gconf_quote_string (gconf_database_get_persistent_name (db));
+        _gconf_quote_string (gconf_database_get_persistent_name (db));
     }
         
   gconf_listeners_foreach (db->listeners,
                            listener_save_foreach,
                            &fd);
@@ -1845,13 +1845,13 @@ static GConfLocaleList*
 locale_cache_lookup(const gchar* locale)
 {
   GConfLocaleList* locale_list;
   
   if (locale_cache == NULL)
-    locale_cache = gconf_locale_cache_new();
+    locale_cache = _gconf_locale_cache_new();
 
-  locale_list = gconf_locale_cache_get_list(locale_cache, locale);
+  locale_list = _gconf_locale_cache_get_list(locale_cache, locale);
 
   g_assert(locale_list != NULL);
   g_assert(locale_list->list != NULL);
   
   return locale_list;
@@ -1859,19 +1859,19 @@ locale_cache_lookup(const gchar* locale)
 
 void
 gconfd_locale_cache_expire(void)
 {
   if (locale_cache != NULL)
-    gconf_locale_cache_expire(locale_cache, 60 * 30); /* 60 sec * 30 min */
+    _gconf_locale_cache_expire(locale_cache, 60 * 30); /* 60 sec * 30 min */
 }
 
 void
 gconfd_locale_cache_drop(void)
 {
   if (locale_cache != NULL)
     {
-      gconf_locale_cache_free(locale_cache);
+      _gconf_locale_cache_free(locale_cache);
       locale_cache = NULL;
     }
 }
 
 /*
Index: gconf/gconf-sources.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconf-sources.c,v
retrieving revision 1.53
diff -p -u -5 -r1.53 gconf-sources.c
--- gconf/gconf-sources.c	27 Oct 2005 11:42:03 -0000	1.53
+++ gconf/gconf-sources.c	4 May 2006 11:21:03 -0000
@@ -36,27 +36,27 @@
 /* 
  *  Sources
  */
 
 GConfSource* 
-gconf_resolve_address(const gchar* address, GError** err)
+_gconf_resolve_address(const gchar* address, GError** err)
 {
   GConfBackend* backend;
 
-  backend = gconf_get_backend(address, err);
+  backend = _gconf_get_backend(address, err);
 
   if (backend == NULL)
     return NULL;
   else
     {
       GConfSource* retval;
 
-      retval = gconf_backend_resolve_address(backend, address, err);
+      retval = _gconf_backend_resolve_address(backend, address, err);
 
       if (retval == NULL)
         {
-          gconf_backend_unref(backend);
+          _gconf_backend_unref(backend);
           return NULL;
         }
       else
         {
           retval->backend = backend;
@@ -68,11 +68,11 @@ gconf_resolve_address(const gchar* addre
         }
     }
 }
 
 void         
-gconf_source_free (GConfSource* source)
+_gconf_source_free (GConfSource* source)
 {
   GConfBackend* backend;
   gchar* address;
   
   g_return_if_fail(source != NULL);
@@ -81,11 +81,11 @@ gconf_source_free (GConfSource* source)
   address = source->address;
 
   (*source->backend->vtable.destroy_source)(source);
   
   /* Remove ref held by the source. */
-  gconf_backend_unref(backend);
+  _gconf_backend_unref(backend);
   g_free(address);
 }
 
 #define SOURCE_READABLE(source, key, err)                  \
      ( ((source)->flags & GCONF_SOURCE_ALL_READABLE) ||    \
@@ -334,11 +334,11 @@ gconf_source_remove_listener (GConfSourc
 /*
  *   Source stacks
  */
 
 GConfSources* 
-gconf_sources_new_from_addresses(GSList * addresses, GError** err)
+_gconf_sources_new_from_addresses(GSList * addresses, GError** err)
 {
   GConfSources *sources;
   GList        *sources_list;
 
   g_return_val_if_fail( (err == NULL) || (*err == NULL), NULL);
@@ -356,11 +356,11 @@ gconf_sources_new_from_addresses(GSList 
 	    {
 	      g_error_free (last_error);
 	      last_error = NULL;
 	    }
       
-	  source = gconf_resolve_address ((const gchar*)addresses->data, &last_error);
+	  source = _gconf_resolve_address ((const gchar*)addresses->data, &last_error);
 
 	  if (source != NULL)
 	    {
 	      sources_list = g_list_prepend(sources_list, source);          
 	      g_return_val_if_fail(last_error == NULL, NULL);
@@ -435,11 +435,11 @@ gconf_sources_new_from_addresses(GSList 
   
   return sources;
 }
 
 GConfSources*
-gconf_sources_new_from_source       (GConfSource* source)
+_gconf_sources_new_from_source       (GConfSource* source)
 {
   GConfSources* sources;
   
   sources = g_new0(GConfSources, 1);
 
@@ -448,30 +448,30 @@ gconf_sources_new_from_source       (GCo
 
   return sources;
 }
 
 void
-gconf_sources_free(GConfSources* sources)
+_gconf_sources_free(GConfSources* sources)
 {
   GList* tmp;
 
   tmp = sources->sources;
 
   while (tmp != NULL)
     {
-      gconf_source_free(tmp->data);
+      _gconf_source_free(tmp->data);
       
       tmp = g_list_next(tmp);
     }
 
   g_list_free(sources->sources);
 
   g_free(sources);
 }
 
 void
-gconf_sources_clear_cache        (GConfSources  *sources)
+_gconf_sources_clear_cache        (GConfSources  *sources)
 {
   GList* tmp;
 
   tmp = sources->sources;
 
@@ -485,11 +485,11 @@ gconf_sources_clear_cache        (GConfS
       tmp = g_list_next(tmp);
     }
 }
 
 GConfValue*   
-gconf_sources_query_value (GConfSources* sources, 
+_gconf_sources_query_value (GConfSources* sources, 
                            const gchar* key,
                            const gchar** locales,
                            gboolean use_schema_default,
                            gboolean* value_is_default,
                            gboolean* value_is_writable,
@@ -509,11 +509,11 @@ gconf_sources_query_value (GConfSources*
    * or if it's set and the setting is within or after a writable source.
    * So basically if we see a writable source before we get the value,
    * or get the value from a writable source, the value is writable.
    */
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return NULL;
 
   if (value_is_default)
     *value_is_default = FALSE;
 
@@ -627,11 +627,11 @@ gconf_sources_query_value (GConfSources*
       if (value_is_default)
         *value_is_default = TRUE;
 
       if (use_schema_default)
         {
-          val = gconf_sources_query_value (sources, schema_name, locales,
+          val = _gconf_sources_query_value (sources, schema_name, locales,
                                            FALSE, NULL, NULL, NULL, &error);
         }
       
       if (error != NULL)
         {
@@ -644,11 +644,11 @@ gconf_sources_query_value (GConfSources*
           return NULL;
         }
       else if (val != NULL &&
                val->type != GCONF_VALUE_SCHEMA)
         {
-          gconf_set_error (err, GCONF_ERROR_FAILED,
+          _gconf_set_error (err, GCONF_ERROR_FAILED,
                            _("Schema `%s' specified for `%s' stores a non-schema value"), schema_name, key);
 
           if (schema_namep)
             *schema_namep = schema_name;
           else
@@ -658,11 +658,11 @@ gconf_sources_query_value (GConfSources*
         }
       else if (val != NULL)
         {
           GConfValue* retval;
 
-          retval = gconf_schema_steal_default_value (gconf_value_get_schema (val));          
+          retval = _gconf_schema_steal_default_value (gconf_value_get_schema (val));          
 
           gconf_value_free (val);
 
           if (schema_namep)
             *schema_namep = schema_name;
@@ -684,11 +684,11 @@ gconf_sources_query_value (GConfSources*
   
   return NULL;
 }
 
 void
-gconf_sources_set_value   (GConfSources* sources,
+_gconf_sources_set_value   (GConfSources* sources,
                            const gchar* key,
                            const GConfValue* value,
 			   GConfSources **modified_sources,
                            GError** err)
 {
@@ -699,18 +699,18 @@ gconf_sources_set_value   (GConfSources*
   g_return_if_fail((err == NULL) || (*err == NULL));
 
   if (modified_sources)
     *modified_sources = NULL;
   
-  if (!gconf_key_check(key, err))
+  if (!_gconf_key_check(key, err))
     return;
   
   g_assert(*key != '\0');
   
   if (key[1] == '\0')
     {
-      gconf_set_error(err, GCONF_ERROR_IS_DIR,
+      _gconf_set_error(err, GCONF_ERROR_IS_DIR,
                       _("The '/' name can only be a directory, not a key"));
       return;
     }
   
   tmp = sources->sources;
@@ -729,11 +729,11 @@ gconf_sources_set_value   (GConfSources*
         {
           /* source was writable, err may be set */
           gconf_log (GCL_DEBUG, "%s was writable in %s", key, src->address);
 	  if (modified_sources)
 	    {
-	      *modified_sources = gconf_sources_new_from_source (src);
+	      *modified_sources = _gconf_sources_new_from_source (src);
 	    }
 	  return;
         }
       else
         {
@@ -748,11 +748,11 @@ gconf_sources_set_value   (GConfSources*
           if (val != NULL)
             {
               gconf_log (GCL_DEBUG, "%s was already set in %s", key, src->address);
               
               gconf_value_free(val);
-              gconf_set_error(err, GCONF_ERROR_OVERRIDDEN,
+              _gconf_set_error(err, GCONF_ERROR_OVERRIDDEN,
                               _("Value for `%s' set in a read-only source at the front of your configuration path"), key);
               return;
             }
         }
 
@@ -766,11 +766,11 @@ gconf_sources_set_value   (GConfSources*
                _("Unable to store a value at key '%s', as the configuration server has no writable databases. There are some common causes of this problem: 1) your configuration path file %s/path doesn't contain any databases or wasn't found 2) somehow we mistakenly created two gconfd processes 3) your operating system is misconfigured so NFS file locking doesn't work in your home directory or 4) your NFS client machine crashed and didn't properly notify the server on reboot that file locks should be dropped. If you have two gconfd processes (or had two at the time the second was launched), logging out, killing all copies of gconfd, and logging back in may help. If you have stale locks, remove ~/.gconf*/*lock. Perhaps the problem is that you attempted to use GConf from two machines at once, and ORBit still has its default configuration that prevents remote CORBA connections - put \"ORBIIOPIPv4=1\" in /etc/orbitrc. As always, check the user.* syslog for details on problems gconfd encountered. There can only be one gconfd per home directory, and it must own a lockfile in ~/.gconfd and also lockfiles in individual storage locations such as ~/.gconf"),           
                key, GCONF_CONFDIR);
 }
 
 void
-gconf_sources_unset_value   (GConfSources* sources,
+_gconf_sources_unset_value   (GConfSources* sources,
                              const gchar* key,
                              const gchar* locale,
 			     GConfSources **modified_sources,
                              GError** err)
 {
@@ -806,11 +806,11 @@ gconf_sources_unset_value   (GConfSource
 
 	  if (modified_sources)
 	    {
 	      if (*modified_sources == NULL)
 		{
-		  *modified_sources = gconf_sources_new_from_source (src);
+		  *modified_sources = _gconf_sources_new_from_source (src);
 		}
 	      else
 		{
 		  (*modified_sources)->sources =
 		    g_list_prepend ((*modified_sources)->sources, src);
@@ -862,11 +862,11 @@ recursive_unset_helper (GConfSources   *
       modifiedp = &modified_sources;
     }
   
   err = NULL;
   
-  subdirs = gconf_sources_all_dirs (sources, key, &err);
+  subdirs = _gconf_sources_all_dirs (sources, key, &err);
           
   if (subdirs != NULL)
     {
       tmp = subdirs;
 
@@ -899,11 +899,11 @@ recursive_unset_helper (GConfSources   *
           err = NULL;
         }
     }
 
   locales[0] = locale;
-  entries = gconf_sources_all_entries (sources, key,
+  entries = _gconf_sources_all_entries (sources, key,
                                        locale ? locales : NULL,
                                        &err);
           
   if (err != NULL)
     {
@@ -927,11 +927,11 @@ recursive_unset_helper (GConfSources   *
 
 	  full = freeme = gconf_concat_dir_and_key (key,
 						    gconf_entry_get_key (entry));
           
           
-          gconf_sources_unset_value (sources, full, locale, modifiedp, &err);
+          _gconf_sources_unset_value (sources, full, locale, modifiedp, &err);
           if (notifies)
 	    {
 	      *notifies = prepend_unset_notify (*notifies, modified_sources, full);
 	      modified_sources = NULL;
 	      freeme = NULL;
@@ -949,11 +949,11 @@ recursive_unset_helper (GConfSources   *
               err = NULL;
             }
 
           if (flags & GCONF_UNSET_INCLUDING_SCHEMA_NAMES)
             {
-              gconf_sources_set_schema (sources,
+              _gconf_sources_set_schema (sources,
                                         full, NULL,
                                         &err);
               if (err != NULL)
                 {
                   gconf_log (GCL_DEBUG, "Error unsetting schema on '%s': %s\n",
@@ -974,11 +974,11 @@ recursive_unset_helper (GConfSources   *
         }
 
       g_slist_free (entries);
     }
 
-  gconf_sources_unset_value (sources, key, locale, modifiedp, &err);
+  _gconf_sources_unset_value (sources, key, locale, modifiedp, &err);
   if (notifies)
     {
       *notifies = prepend_unset_notify (*notifies,
 					modified_sources,
 					g_strdup (key));
@@ -997,11 +997,11 @@ recursive_unset_helper (GConfSources   *
       err = NULL;
     }
 }
 
 void
-gconf_sources_recursive_unset (GConfSources   *sources,
+_gconf_sources_recursive_unset (GConfSources   *sources,
                                const gchar    *key,
                                const gchar    *locale,
                                GConfUnsetFlags flags,
                                GSList        **notifies,
                                GError        **err)
@@ -1040,17 +1040,17 @@ gconf_sources_recursive_unset (GConfSour
       g_propagate_error (err, first_error);
     }
 }
 
 gboolean
-gconf_sources_dir_exists (GConfSources* sources,
+_gconf_sources_dir_exists (GConfSources* sources,
                           const gchar* dir,
                           GError** err)
 {
   GList *tmp;
 
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return FALSE;
   
   tmp = sources->sources;
   
   while (tmp != NULL) 
@@ -1065,18 +1065,18 @@ gconf_sources_dir_exists (GConfSources* 
   
   return FALSE;
 }
           
 void          
-gconf_sources_remove_dir (GConfSources* sources,
+_gconf_sources_remove_dir (GConfSources* sources,
                           const gchar* dir,
                           GError** err)
 {
   /* We remove in every layer we can write to... */
   GList* tmp;
   
-  if (!gconf_key_check(dir, err))
+  if (!_gconf_key_check(dir, err))
     return;
   
   tmp = sources->sources;
 
   while (tmp != NULL)
@@ -1105,21 +1105,21 @@ gconf_sources_remove_dir (GConfSources* 
       tmp = g_list_next(tmp);
     }
 }
 
 void         
-gconf_sources_set_schema (GConfSources *sources,
+_gconf_sources_set_schema (GConfSources *sources,
                           const gchar  *key,
                           const gchar  *schema_key,
                           GError      **err)
 {
   GList* tmp;
 
-  if (!gconf_key_check (key, err))
+  if (!_gconf_key_check (key, err))
     return;
 
-  if (schema_key && !gconf_key_check (schema_key, err))
+  if (schema_key && !_gconf_key_check (schema_key, err))
     return;
   
   tmp = sources->sources;
 
   while (tmp != NULL)
@@ -1185,11 +1185,11 @@ hash_lookup_defaults_func(gpointer key, 
       if (gconf_entry_get_schema_name(entry) != NULL)
         {
           GConfValue *val;
 
 
-          val = gconf_sources_query_value(sources,
+          val = _gconf_sources_query_value(sources,
                                           gconf_entry_get_schema_name(entry),
                                           locales,
                                           TRUE,
                                           NULL,
                                           NULL,
@@ -1199,11 +1199,11 @@ hash_lookup_defaults_func(gpointer key, 
           if (val != NULL &&
               val->type == GCONF_VALUE_SCHEMA)
             {
               GConfValue* defval;
 
-              defval = gconf_schema_steal_default_value (gconf_value_get_schema(val));
+              defval = _gconf_schema_steal_default_value (gconf_value_get_schema(val));
 
               gconf_entry_set_value_nocopy (entry, defval);
               gconf_entry_set_is_default (entry, TRUE);
             }
 
@@ -1244,11 +1244,11 @@ key_is_writable (GConfSources *sources,
   /* This shouldn't be reached actually */
   return FALSE;
 }
 
 GSList*       
-gconf_sources_all_entries   (GConfSources* sources,
+_gconf_sources_all_entries   (GConfSources* sources,
                              const gchar* dir,
                              const gchar** locales,
                              GError** err)
 {
   GList* tmp;
@@ -1398,11 +1398,11 @@ gconf_sources_all_entries   (GConfSource
   
   return flattened;
 }
 
 GSList*       
-gconf_sources_all_dirs   (GConfSources* sources,
+_gconf_sources_all_dirs   (GConfSources* sources,
                           const gchar* dir,
                           GError** err)
 {
   GList* tmp = NULL;
   GHashTable* hash = NULL;
@@ -1503,11 +1503,11 @@ gconf_sources_all_dirs   (GConfSources* 
 
   return flattened;
 }
 
 gboolean
-gconf_sources_sync_all    (GConfSources* sources, GError** err)
+_gconf_sources_sync_all    (GConfSources* sources, GError** err)
 {
   GList* tmp;
   gboolean failed = FALSE;
   GError* all_errors = NULL;
   
@@ -1526,11 +1526,11 @@ gconf_sources_sync_all    (GConfSources*
           
       /* On error, set error and bail */
       if (error != NULL)
         {
           if (err)
-            all_errors = gconf_compose_errors(all_errors, error);
+            all_errors = _gconf_compose_errors(all_errors, error);
 
           g_error_free(error);
         }
           
       tmp = g_list_next(tmp);
@@ -1544,11 +1544,11 @@ gconf_sources_sync_all    (GConfSources*
   
   return !failed;
 }
 
 GConfMetaInfo*
-gconf_sources_query_metainfo (GConfSources* sources,
+_gconf_sources_query_metainfo (GConfSources* sources,
                               const gchar* key,
                               GError** err)
 {
   GList* tmp;
   GConfMetaInfo* mi = NULL;
@@ -1609,11 +1609,11 @@ gconf_sources_query_metainfo (GConfSourc
   
   return mi;
 }
 
 GConfValue*
-gconf_sources_query_default_value(GConfSources* sources,
+_gconf_sources_query_default_value(GConfSources* sources,
                                   const gchar* key,
                                   const gchar** locales,
                                   gboolean* is_writable,
                                   GError** err)
 {
@@ -1624,11 +1624,11 @@ gconf_sources_query_default_value(GConfS
   g_return_val_if_fail(err == NULL || *err == NULL, NULL);
 
   if (is_writable)
     *is_writable = key_is_writable (sources, NULL, key, NULL);
   
-  mi = gconf_sources_query_metainfo(sources, key,
+  mi = _gconf_sources_query_metainfo(sources, key,
                                     &error);
   if (mi == NULL)
     {
       if (error != NULL)
         {
@@ -1647,11 +1647,11 @@ gconf_sources_query_default_value(GConfS
     {
       gconf_meta_info_free(mi);
       return NULL;
     }
       
-  val = gconf_sources_query_value(sources,
+  val = _gconf_sources_query_value(sources,
                                   gconf_meta_info_get_schema(mi), locales,
                                   TRUE, NULL, NULL, NULL, &error);
   
   if (val != NULL)
     {
@@ -1661,26 +1661,26 @@ gconf_sources_query_default_value(GConfS
         {
           gconf_log(GCL_WARNING,
                     _("Key `%s' listed as schema for key `%s' actually stores type `%s'"),
                     gconf_meta_info_get_schema(mi),
                     key,
-                    gconf_value_type_to_string(val->type));
+                    _gconf_value_type_to_string(val->type));
 
           gconf_meta_info_free(mi);
           return NULL;
         }
 
       gconf_meta_info_free(mi);
 
-      schema = gconf_value_steal_schema (val);
+      schema = _gconf_value_steal_schema (val);
       gconf_value_free (val);
       
       if (schema != NULL)
         {
           GConfValue* retval;
 
-          retval = gconf_schema_steal_default_value (schema);
+          retval = _gconf_schema_steal_default_value (schema);
 
           gconf_schema_free (schema);
           
           return retval;
         }
@@ -1706,11 +1706,11 @@ gconf_sources_query_default_value(GConfS
       return NULL;
     }
 }
 
 void
-gconf_sources_set_notify_func (GConfSources          *sources,
+_gconf_sources_set_notify_func (GConfSources          *sources,
 			       GConfSourceNotifyFunc  notify_func,
 			       gpointer               user_data)
 {
   GList *tmp;
 
@@ -1722,11 +1722,11 @@ gconf_sources_set_notify_func (GConfSour
       tmp = tmp->next;
     }
 }
 
 void
-gconf_sources_add_listener (GConfSources *sources,
+_gconf_sources_add_listener (GConfSources *sources,
 			    guint         id,
 			    const gchar  *namespace_section)
 {
   GList *tmp;
 
@@ -1738,11 +1738,11 @@ gconf_sources_add_listener (GConfSources
       tmp = tmp->next;
     }
 }
 
 void
-gconf_sources_remove_listener (GConfSources *sources,
+_gconf_sources_remove_listener (GConfSources *sources,
 			       guint         id)
 {
   GList *tmp;
 
   tmp = sources->sources;
@@ -1752,11 +1752,11 @@ gconf_sources_remove_listener (GConfSour
 
       tmp = tmp->next;
     }
 }
 
-/* Non-allocating variant of gconf_address_resource()
+/* Non-allocating variant of _gconf_address_resource()
  */
 static const char *
 get_address_resource (const char *address)
 {
   const char *start;
@@ -1778,11 +1778,11 @@ get_address_resource (const char *addres
 /* Return TRUE if
  *  1. @sources contains @modified_src and
  *  2. @key is not set in any source above @modified_src.
  */
 gboolean
-gconf_sources_is_affected (GConfSources *sources,
+_gconf_sources_is_affected (GConfSources *sources,
                            GConfSource  *modified_src,
                            const char   *key)
 {
   const char *modified_resource;
   GList      *tmp;
Index: gconf/gconftool.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconftool.c,v
retrieving revision 1.103
diff -p -u -5 -r1.103 gconftool.c
--- gconf/gconftool.c	6 Mar 2006 13:05:46 -0000	1.103
+++ gconf/gconftool.c	4 May 2006 11:21:03 -0000
@@ -735,11 +735,11 @@ main (int argc, char** argv)
 
   /* Do this first, since we want to do only this if the user selected
      it. */
   if (ping_gconfd)
     {
-      if (gconf_ping_daemon())
+      if (_gconf_ping_daemon())
         return 0;
       else 
         return 2;
     }
 
@@ -787,27 +787,27 @@ main (int argc, char** argv)
         }
 
       use_local_source = TRUE;
 
       /* shut down daemon, this is a race condition, but will usually work. */
-      gconf_shutdown_daemon (NULL);
+      _gconf_shutdown_daemon (NULL);
     }
 
   if (config_source == NULL)
     conf = gconf_engine_get_default();
   else
     {
       GSList *addresses;
 
-      addresses = gconf_persistent_name_get_address_list (config_source);
+      addresses = _gconf_persistent_name_get_address_list (config_source);
 
       if (use_local_source)
         conf = gconf_engine_get_local_for_addresses (addresses, &err);
       else
         conf = gconf_engine_get_for_addresses (addresses, &err);
 
-      gconf_address_list_free (addresses);
+      _gconf_address_list_free (addresses);
     }
   
   if (conf == NULL)
     {
       g_assert(err != NULL);
@@ -1113,11 +1113,11 @@ main (int argc, char** argv)
   gconf_engine_unref(conf);
 
   if (shutdown_gconfd)
     {
       err = NULL;
-      gconf_shutdown_daemon(&err);
+      _gconf_shutdown_daemon(&err);
     }
       
   if (err != NULL)
     {
       g_printerr (_("Shutdown error: %s\n"),
@@ -1340,18 +1340,18 @@ print_schema_in_xml(GConfValue* value, i
   g_print ("%s<schema>\n", whitespace);
 
   if (owner)
     g_print ("%s  <owner>%s</owner>\n", whitespace, owner);
 
-  g_print ("%s  <type>%s</type>\n", whitespace, gconf_value_type_to_string(type));
+  g_print ("%s  <type>%s</type>\n", whitespace, _gconf_value_type_to_string(type));
 
   if (type == GCONF_VALUE_LIST)
-    g_print ("%s  <list_type>%s</list_type>\n", whitespace, gconf_value_type_to_string(list_type));
+    g_print ("%s  <list_type>%s</list_type>\n", whitespace, _gconf_value_type_to_string(list_type));
   else if (type == GCONF_VALUE_PAIR)
     {
-      g_print ("%s  <car_type>%s</car_type>\n", whitespace, gconf_value_type_to_string(car_type));
-      g_print ("%s  <cdr_type>%s</cdr_type>\n", whitespace, gconf_value_type_to_string(cdr_type));
+      g_print ("%s  <car_type>%s</car_type>\n", whitespace, _gconf_value_type_to_string(car_type));
+      g_print ("%s  <cdr_type>%s</cdr_type>\n", whitespace, _gconf_value_type_to_string(cdr_type));
     }
 
   g_print ("%s  <locale name=\"%s\">\n", whitespace, gconf_schema_get_locale (schema));
 
   if (default_value)
@@ -1413,11 +1413,11 @@ print_list_in_xml(GConfValue* value, int
 
   whitespace = g_strnfill(indent, ' ');
 
   list_type = gconf_value_get_list_type(value);
 
-  g_print ("%s<list type=\"%s\">\n", whitespace, gconf_value_type_to_string(list_type));
+  g_print ("%s<list type=\"%s\">\n", whitespace, _gconf_value_type_to_string(list_type));
 
   tmp = gconf_value_get_list(value);
   while (tmp)
     {
       print_value_in_xml(tmp->data, indent + 4);
@@ -1578,11 +1578,11 @@ do_dir_exists(GConfEngine* conf, const g
 static void
 do_spawn_daemon(GConfEngine* conf)
 {
   GError* err = NULL;
 
-  if (!gconf_spawn_daemon(&err))
+  if (!_gconf_spawn_daemon(&err))
     {
       g_printerr (_("Failed to spawn the config server (gconfd): %s\n"), 
 		  err->message);
       g_error_free(err);
       err = NULL;
@@ -1644,14 +1644,14 @@ do_get(GConfEngine* conf, const gchar** 
               const gchar* long_desc = gconf_schema_get_long_desc(sc);
               const gchar* short_desc = gconf_schema_get_short_desc(sc);
               const gchar* owner = gconf_schema_get_owner(sc);
               GConfValue* def_value = gconf_schema_get_default_value(sc);
               
-              g_print (_("Type: %s\n"), gconf_value_type_to_string(stype));
-              g_print (_("List Type: %s\n"), gconf_value_type_to_string(slist_type));
-              g_print (_("Car Type: %s\n"), gconf_value_type_to_string(scar_type));
-              g_print (_("Cdr Type: %s\n"), gconf_value_type_to_string(scdr_type));
+              g_print (_("Type: %s\n"), _gconf_value_type_to_string(stype));
+              g_print (_("List Type: %s\n"), _gconf_value_type_to_string(slist_type));
+              g_print (_("Car Type: %s\n"), _gconf_value_type_to_string(scar_type));
+              g_print (_("Cdr Type: %s\n"), _gconf_value_type_to_string(scdr_type));
               if (def_value)
                 s = gconf_value_to_string (def_value);
               else
                 s = NULL;
               g_print (_("Default Value: %s\n"), def_value ? s : _("Unset"));
@@ -1815,13 +1815,13 @@ do_set(GConfEngine* conf, const gchar** 
 	}
 
       err = NULL;
 
       if (type == GCONF_VALUE_LIST)
-	gval = gconf_value_new_list_from_string(list_type, value, &err);
+	gval = _gconf_value_new_list_from_string(list_type, value, &err);
       else if (type == GCONF_VALUE_PAIR)
-	gval = gconf_value_new_pair_from_string(car_type, cdr_type, value, &err);
+	gval = _gconf_value_new_pair_from_string(car_type, cdr_type, value, &err);
       else
         gval = gconf_value_new_from_string(type, value, &err);
 
       if (gval == NULL)
         {
@@ -1883,11 +1883,11 @@ do_get_type(GConfEngine* conf, const gch
 
       value = get_maybe_without_default (conf, *args, &err);
          
       if (value != NULL)
 	{
-	  g_print ("%s\n", gconf_value_type_to_string (value->type));
+	  g_print ("%s\n", _gconf_value_type_to_string (value->type));
 	}
       else
         {
           if (err == NULL)
             {
@@ -2395,11 +2395,11 @@ do_recursive_unset (GConfEngine* conf, c
   while (*args)
     {
       GError *err;
 
       err = NULL;
-      gconf_engine_recursive_unset (conf, *args,
+      _gconf_engine_recursive_unset (conf, *args,
                                     GCONF_UNSET_INCLUDING_SCHEMA_NAMES,
                                     &err);
       if (err != NULL)
         {
           g_printerr (_("Failure during recursive unset of \"%s\": %s\n"),
@@ -2500,11 +2500,11 @@ get_list_value_from_xml(xmlNodePtr node,
     {
       g_printerr ("WARNING: must specify a list type for using <list type=\"type\">\n");
       return 1;
     }
 
-  list_type = gconf_value_type_from_string(list_type_str);
+  list_type = _gconf_value_type_from_string(list_type_str);
 
   xmlFree(list_type_str);
 
   if (list_type == GCONF_VALUE_INVALID)
     {
@@ -2524,12 +2524,12 @@ get_list_value_from_xml(xmlNodePtr node,
             {
               if (element->type == list_type)
                 list = g_slist_prepend (list, element);
               else
                 g_printerr ("WARNING: list type and element type do not match: %s != %s\n",
-			    gconf_value_type_to_string (list_type),
-			    gconf_value_type_to_string (element->type));
+			    _gconf_value_type_to_string (list_type),
+			    _gconf_value_type_to_string (element->type));
             }
         }
 
       iter = iter->next;
     }
@@ -2975,11 +2975,11 @@ fill_default_from_string(SchemaInfo* inf
 	  {
             g_printerr (_("WARNING: invalid or missing list_type for schema (%s)\n"),
 			info->key);
             break;
 	  }
-        *retloc = gconf_value_new_list_from_string(info->list_type,
+        *retloc = _gconf_value_new_list_from_string(info->list_type,
 						   default_value,
 						   &error);
         if (*retloc == NULL)
           {
             g_assert(error != NULL);
@@ -3004,11 +3004,11 @@ fill_default_from_string(SchemaInfo* inf
 	  {
             g_printerr (_("WARNING: invalid or missing car_type or cdr_type for schema (%s)\n"),
                     info->key);
             break;
 	  }
-        *retloc = gconf_value_new_pair_from_string(info->car_type,
+        *retloc = _gconf_value_new_pair_from_string(info->car_type,
 						   info->cdr_type,
 						   default_value,
 						   &error);
         if (*retloc == NULL)
           {
@@ -3100,11 +3100,11 @@ extract_global_info(xmlNodePtr node,
           else if (strcmp(iter->name, "type") == 0)
             {
               tmp = xmlNodeGetContent(iter);
               if (tmp)
                 {
-                  info->type = gconf_value_type_from_string(tmp);
+                  info->type = _gconf_value_type_from_string(tmp);
                   if (info->type == GCONF_VALUE_INVALID)
                     g_printerr (_("WARNING: failed to parse type name `%s'\n"),
 				tmp);
                   xmlFree(tmp);
                 }
@@ -3112,11 +3112,11 @@ extract_global_info(xmlNodePtr node,
           else if (strcmp(iter->name, "list_type") == 0)
             {
               tmp = xmlNodeGetContent(iter);
               if (tmp)
                 {
-                  info->list_type = gconf_value_type_from_string(tmp);
+                  info->list_type = _gconf_value_type_from_string(tmp);
                   if (info->list_type != GCONF_VALUE_INT &&
 		      info->list_type != GCONF_VALUE_FLOAT &&
 		      info->list_type != GCONF_VALUE_STRING &&
 		      info->list_type != GCONF_VALUE_BOOL)
 		    {
@@ -3133,11 +3133,11 @@ extract_global_info(xmlNodePtr node,
           else if (strcmp(iter->name, "car_type") == 0)
             {
               tmp = xmlNodeGetContent(iter);
               if (tmp)
                 {
-                  info->car_type = gconf_value_type_from_string(tmp);
+                  info->car_type = _gconf_value_type_from_string(tmp);
                   if (info->car_type != GCONF_VALUE_INT &&
 		      info->car_type != GCONF_VALUE_FLOAT &&
 		      info->car_type != GCONF_VALUE_STRING &&
 		      info->car_type != GCONF_VALUE_BOOL)
 		    {
@@ -3154,11 +3154,11 @@ extract_global_info(xmlNodePtr node,
           else if (strcmp(iter->name, "cdr_type") == 0)
             {
               tmp = xmlNodeGetContent(iter);
               if (tmp)
                 {
-                  info->cdr_type = gconf_value_type_from_string(tmp);
+                  info->cdr_type = _gconf_value_type_from_string(tmp);
                   if (info->cdr_type != GCONF_VALUE_INT &&
 		      info->cdr_type != GCONF_VALUE_FLOAT &&
 		      info->cdr_type != GCONF_VALUE_STRING &&
 		      info->cdr_type != GCONF_VALUE_BOOL)
 		    {
Index: gconf/gconfd.c
===================================================================
RCS file: /export/cvs/head/gconf/gconf/gconfd.c,v
retrieving revision 1.156
diff -p -u -5 -r1.156 gconfd.c
--- gconf/gconfd.c	27 Jan 2006 13:13:44 -0000	1.156
+++ gconf/gconfd.c	4 May 2006 11:21:03 -0000
@@ -320,22 +320,22 @@ gconf_server_load_sources(void)
   GConfSources* sources = NULL;
   GError* error = NULL;
   
   conffile = g_strconcat(GCONF_CONFDIR, "/path", NULL);
 
-  addresses = gconf_load_source_path(conffile, NULL);
+  addresses = _gconf_load_source_path(conffile, NULL);
 
   g_free(conffile);
 
 #ifdef GCONF_ENABLE_DEBUG
   /* -- Debug only */
   
   if (addresses == NULL)
     {
       gconf_log(GCL_DEBUG, _("gconfd compiled with debugging; trying to load gconf.path from the source directory"));
       conffile = g_strconcat(GCONF_SRCDIR, "/gconf/gconf.path", NULL);
-      addresses = gconf_load_source_path(conffile, NULL);
+      addresses = _gconf_load_source_path(conffile, NULL);
       g_free(conffile);
     }
 
   /* -- End of Debug Only */
 #endif
@@ -359,29 +359,29 @@ gconf_server_load_sources(void)
       /* We want to stay alive but do nothing, because otherwise every
          request would result in another failed gconfd being spawned.  
       */
       gconf_log(GCL_ERR, _("No configuration sources in the source path, configuration won't be saved; edit %s%s"), GCONF_CONFDIR, "/path");
       /* don't request error since there aren't any addresses */
-      sources = gconf_sources_new_from_addresses(NULL, NULL);
+      sources = _gconf_sources_new_from_addresses(NULL, NULL);
 
       /* Install the sources as the default database */
       set_default_database (gconf_database_new(sources));
     }
   else
     {
-      sources = gconf_sources_new_from_addresses(addresses, &error);
+      sources = _gconf_sources_new_from_addresses(addresses, &error);
 
       if (error != NULL)
         {
           gconf_log(GCL_ERR, _("Error loading some config sources: %s"),
                     error->message);
 
           g_error_free(error);
           error = NULL;
         }
       
-      gconf_address_list_free(addresses);
+      _gconf_address_list_free(addresses);
 
       g_assert(sources != NULL);
 
       if (sources->sources == NULL)
         gconf_log(GCL_ERR, _("No config source addresses successfully resolved, can't load or store config data"));
@@ -652,11 +652,11 @@ main(int argc, char** argv)
       gconf_log_debug_messages = TRUE;
     }
   
   umask (022);
   
-  gconf_set_daemon_mode(TRUE);
+  _gconf_set_daemon_mode(TRUE);
   
   /* Logs */
   username = g_get_user_name();
   logname = g_strdup_printf("gconfd (%s-%u)", username, (guint)getpid());
 
@@ -719,11 +719,11 @@ main(int argc, char** argv)
 
   CORBA_exception_init(&ev);
 
   init_databases ();
 
-  orb = gconf_orb_get ();
+  orb = _gconf_orb_get ();
   
   POA_ConfigServer2__init (&poa_server_servant, &ev);
   
   the_poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(orb, "RootPOA", &ev);
   PortableServer_POAManager_activate(PortableServer_POA__get_the_POAManager(the_poa, &ev), &ev);
@@ -737,15 +737,15 @@ main(int argc, char** argv)
       return 1;
     }
 
   /* Needs to be done before loading sources */
   ior = CORBA_ORB_object_to_string (orb, server, &ev);
-  gconf_set_daemon_ior (ior);
+  _gconf_set_daemon_ior (ior);
   CORBA_free (ior);
 
-  gconfd_dir = gconf_get_daemon_dir ();
-  lock_dir = gconf_get_lock_dir ();
+  gconfd_dir = _gconf_get_daemon_dir ();
+  lock_dir = _gconf_get_lock_dir ();
   
   if (g_mkdir (gconfd_dir, 0700) < 0 && errno != EEXIST)
     gconf_log (GCL_WARNING, _("Failed to create %s: %s"),
                gconfd_dir, g_strerror (errno));
   
@@ -759,11 +759,11 @@ main(int argc, char** argv)
     }
   else
     {
       err = NULL;
       
-      daemon_lock = gconf_get_lock (lock_dir, &err);
+      daemon_lock = _gconf_get_lock (lock_dir, &err);
     }
 
   g_free (gconfd_dir);
   g_free (lock_dir);
 
@@ -828,11 +828,11 @@ main(int argc, char** argv)
   gconfd_locale_cache_drop ();
 
   if (daemon_lock)
     {
       err = NULL;
-      gconf_release_lock (daemon_lock, &err);
+      _gconf_release_lock (daemon_lock, &err);
       if (err != NULL)
         {
           gconf_log (GCL_WARNING, _("Error releasing lockfile: %s"),
                      err->message);
           g_error_free (err);
@@ -1024,11 +1024,11 @@ lookup_database (GSList *addresses)
   char          *key;
 
   if (addresses == NULL)
     return default_db;
 
-  key = gconf_address_list_get_persistent_name (addresses);
+  key = _gconf_address_list_get_persistent_name (addresses);
 
   retval = g_hash_table_lookup (dbs_by_addresses, key);
 
   g_free (key);
 
@@ -1046,11 +1046,11 @@ obtain_database (GSList  *addresses,
   db = lookup_database (addresses);
 
   if (db)
     return db;
 
-  sources = gconf_sources_new_from_addresses(addresses, &error);
+  sources = _gconf_sources_new_from_addresses(addresses, &error);
 
   if (error != NULL)
     {
       if (err)
         *err = error;
@@ -1187,11 +1187,11 @@ gconfd_notify_other_listeners (GConfData
 	  tmp2 = modified_sources->sources;
 	  while (tmp2)
 	    {
 	      GConfSource *modified_source = tmp2->data;
 
-	      if (gconf_sources_is_affected (db->sources, modified_source, key))
+	      if (_gconf_sources_is_affected (db->sources, modified_source, key))
 		{
 		  GConfValue  *value;
 		  ConfigValue *cvalue;
 		  GError      *error;
 		  gboolean     is_default;
@@ -1215,16 +1215,16 @@ gconfd_notify_other_listeners (GConfData
 		      return;
 		    }
 
 		  if (value != NULL)
 		    {
-		      cvalue = gconf_corba_value_from_gconf_value (value);
+		      cvalue = _gconf_corba_value_from_gconf_value (value);
 		      gconf_value_free (value);
 		    }
 		  else
 		    {
-		      cvalue = gconf_invalid_corba_value ();
+		      cvalue = _gconf_invalid_corba_value ();
 		    }
 
 		  gconf_database_notify_listeners (db,
 						   NULL,
 						   key,
@@ -1439,11 +1439,11 @@ open_append_handle (GError **err)
       
       append_handle = g_fopen (logfile, "a");
 
       if (append_handle == NULL)
         {
-          gconf_set_error (err,
+          _gconf_set_error (err,
                            GCONF_ERROR_FAILED,
                            _("Failed to open gconfd logfile; won't be able to restore listeners after gconfd shutdown (%s)"),
                            g_strerror (errno));
           
           g_free (logdir);
@@ -1569,11 +1569,11 @@ logfile_save (void)
     }
 
   fd = -1;
   
   /* Move the main saved state file aside, if it exists */
-  if (gconf_file_exists (logfile))
+  if (_gconf_file_exists (logfile))
     {
       tmpfile2 = g_strconcat (logfile, ".orig", NULL);
       if (g_rename (logfile, tmpfile2) < 0)
         {
           gconf_log (GCL_WARNING,
@@ -1713,11 +1713,11 @@ parse_listener_entry (GHashTable *entrie
   while (*p && g_ascii_isspace (*p))
     ++p;
 
   err = NULL;
   end = NULL;
-  gconf_unquote_string_inplace (p, &end, &err);
+  _gconf_unquote_string_inplace (p, &end, &err);
   if (err != NULL)
     {
       gconf_log (GCL_DEBUG,
                  "Failed to unquote config source address from saved state file: %s",
                  err->message);
@@ -1733,11 +1733,11 @@ parse_listener_entry (GHashTable *entrie
   while (*p && g_ascii_isspace (*p))
     ++p;
   
   err = NULL;
   end = NULL;
-  gconf_unquote_string_inplace (p, &end, &err);
+  _gconf_unquote_string_inplace (p, &end, &err);
   if (err != NULL)
     {
       gconf_log (GCL_DEBUG,
                  "Failed to unquote listener location from saved state file: %s",
                  err->message);
@@ -1753,11 +1753,11 @@ parse_listener_entry (GHashTable *entrie
   while (*p && g_ascii_isspace (*p))
     ++p;
   
   err = NULL;
   end = NULL;
-  gconf_unquote_string_inplace (p, &end, &err);
+  _gconf_unquote_string_inplace (p, &end, &err);
   if (err != NULL)
     {
       gconf_log (GCL_DEBUG,
                  "Failed to unquote IOR from saved state file: %s",
                  err->message);
@@ -1857,11 +1857,11 @@ parse_client_entry (GHashTable *clients,
   while (*p && g_ascii_isspace (*p))
     ++p;
   
   err = NULL;
   end = NULL;
-  gconf_unquote_string_inplace (p, &end, &err);
+  _gconf_unquote_string_inplace (p, &end, &err);
   if (err != NULL)
     {
       gconf_log (GCL_DEBUG,
                  "Failed to unquote IOR from saved state file: %s",
                  err->message);
@@ -1918,11 +1918,11 @@ restore_client (const gchar *ior)
   ConfigListener cl;
   CORBA_Environment ev;
   
   CORBA_exception_init (&ev);
   
-  cl = CORBA_ORB_string_to_object (gconf_orb_get (), (gchar*)ior, &ev);
+  cl = CORBA_ORB_string_to_object (_gconf_orb_get (), (gchar*)ior, &ev);
 
   CORBA_exception_free (&ev);
   
   if (CORBA_Object_is_nil (cl, &ev))
     {
@@ -1965,11 +1965,11 @@ restore_listener (GConfDatabase* db,
   guint new_cnxn;
   GError *err;
   
   CORBA_exception_init (&ev);
   
-  cl = CORBA_ORB_string_to_object (gconf_orb_get (), lle->ior, &ev);
+  cl = CORBA_ORB_string_to_object (_gconf_orb_get (), lle->ior, &ev);
 
   CORBA_exception_free (&ev);
   
   if (CORBA_Object_is_nil (cl, &ev))
     {
@@ -2063,15 +2063,15 @@ listener_logentry_restore_and_destroy_fo
     db = default_db;
   else
     {
       GSList *addresses;
 
-      addresses = gconf_persistent_name_get_address_list (lle->address);
+      addresses = _gconf_persistent_name_get_address_list (lle->address);
 
       db = obtain_database (addresses, NULL);
 
-      gconf_address_list_free (addresses);
+      _gconf_address_list_free (addresses);
     }
   
   if (db == NULL)
     {
       gconf_log (GCL_WARNING,
@@ -2236,31 +2236,31 @@ gconfd_logfile_change_listener (GConfDat
   gchar *quoted_ior;
   
   if (!open_append_handle (err))
     return FALSE;
   
-  ior = gconf_object_to_string (listener, err);
+  ior = _gconf_object_to_string (listener, err);
   
   if (ior == NULL)
     return FALSE;
 
-  quoted_ior = gconf_quote_string (ior);
+  quoted_ior = _gconf_quote_string (ior);
   g_free (ior);
   ior = NULL;
   
   if (db == default_db)
-    quoted_db_name = gconf_quote_string ("def");
+    quoted_db_name = _gconf_quote_string ("def");
   else
     {
       const gchar *db_name;
       
       db_name = gconf_database_get_persistent_name (db);
       
-      quoted_db_name = gconf_quote_string (db_name);
+      quoted_db_name = _gconf_quote_string (db_name);
     }
 
-  quoted_where = gconf_quote_string (where);
+  quoted_where = _gconf_quote_string (where);
 
   /* KEEP IN SYNC with gconf-database.c log to string function */
   if (fprintf (append_handle, "%s %u %s %s %s\n",
                add ? "ADD" : "REMOVE", connection_id,
                quoted_db_name, quoted_where, quoted_ior) < 0)
@@ -2276,16 +2276,16 @@ gconfd_logfile_change_listener (GConfDat
   return TRUE;
 
  error:
 
   if (add)
-    gconf_set_error (err,
+    _gconf_set_error (err,
                      GCONF_ERROR_FAILED,
                      _("Failed to log addition of listener to gconfd logfile; won't be able to re-add the listener if gconfd exits or shuts down (%s)"),
                      g_strerror (errno));
   else
-    gconf_set_error (err,
+    _gconf_set_error (err,
                      GCONF_ERROR_FAILED,
                      _("Failed to log removal of listener to gconfd logfile; might erroneously re-add the listener if gconfd exits or shuts down (%s)"),
                      g_strerror (errno));
 
   g_free (quoted_db_name);
@@ -2302,11 +2302,11 @@ log_client_change (const ConfigListener 
   gchar *ior = NULL;
   gchar *quoted_ior = NULL;
   GError *err;
   
   err = NULL;
-  ior = gconf_object_to_string (client, &err);
+  ior = _gconf_object_to_string (client, &err);
 
   if (err != NULL)
     {
       gconf_log (GCL_WARNING, _("Failed to get IOR for client: %s"),
                  err->message);
@@ -2315,11 +2315,11 @@ log_client_change (const ConfigListener 
     }
       
   if (ior == NULL)
     return;
 
-  quoted_ior = gconf_quote_string (ior);
+  quoted_ior = _gconf_quote_string (ior);
   g_free (ior);
   ior = NULL;
   
   if (!open_append_handle (&err))
     {
@@ -2376,12 +2376,12 @@ static void
 add_client (const ConfigListener client)
 {
   gconfd_need_log_cleanup ();
   
   if (client_table == NULL)
-    client_table = g_hash_table_new ((GHashFunc) gconf_CORBA_Object_hash,
-                                     (GCompareFunc) gconf_CORBA_Object_equal);
+    client_table = g_hash_table_new ((GHashFunc) _gconf_CORBA_Object_hash,
+                                     (GCompareFunc) _gconf_CORBA_Object_equal);
 
   if (g_hash_table_lookup (client_table, client))
     {
       /* Ignore this case; it happens normally when we added a client
        * from the logfile, and the client also adds itself
@@ -2476,11 +2476,11 @@ log_clients_foreach (gpointer key, gpoin
   GError *err;
 
   client = value;
   
   err = NULL;
-  ior = gconf_object_to_string (client, &err);
+  ior = _gconf_object_to_string (client, &err);
 
   if (err != NULL)
     {
       gconf_log (GCL_WARNING, _("Failed to get IOR for client: %s"),
                  err->message);
@@ -2489,11 +2489,11 @@ log_clients_foreach (gpointer key, gpoin
     }
       
   if (ior == NULL)
     return;
 
-  quoted_ior = gconf_quote_string (ior);
+  quoted_ior = _gconf_quote_string (ior);
   g_free (ior);
   ior = NULL;
 
   g_string_append (data, "CLIENTADD ");
   g_string_append (data, quoted_ior);
Index: tests/testpersistence.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testpersistence.c,v
retrieving revision 1.12
diff -p -u -5 -r1.12 testpersistence.c
--- tests/testpersistence.c	22 Mar 2002 01:08:48 -0000	1.12
+++ tests/testpersistence.c	4 May 2006 11:21:04 -0000
@@ -706,11 +706,11 @@ compare_lists(GConfValueType type, GSLis
       l1 = g_slist_next(l1);
       l2 = g_slist_next(l2);
     }
 
   check(l2 == NULL, "second list too long with list type %s",
-        gconf_value_type_to_string(type));
+        _gconf_value_type_to_string(type));
 }
 
 static void
 free_list(GConfValueType type, GSList* list)
 {
Index: tests/testaddress.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testaddress.c,v
retrieving revision 1.5
diff -p -u -5 -r1.5 testaddress.c
--- tests/testaddress.c	29 Mar 2002 06:27:13 -0000	1.5
+++ tests/testaddress.c	4 May 2006 11:21:04 -0000
@@ -112,30 +112,30 @@ main (int argc, char** argv)
 
       address = g_strconcat(iter->protocol, ":", flat_flags, ":", iter->resource, NULL);
 
       g_free(flat_flags);
       
-      protocol = gconf_address_backend(address);
+      protocol = _gconf_address_backend(address);
 
       check(protocol != NULL,
             "protocol wasn't extracted from `%s'",
             address);
       check (strcmp(protocol, iter->protocol) == 0,
              "protocol extracted was wrong: `%s' vs. `%s' from `%s'",
              protocol, iter->protocol, address);
       
-      resource = gconf_address_resource(address);
+      resource = _gconf_address_resource(address);
 
       check(resource != NULL,
             "resource wasn't extracted from `%s'",
             address);      
 
       check (strcmp(resource, iter->resource) == 0,
              "resource extracted was wrong: `%s' vs. `%s' from `%s'",
              resource, iter->resource, address);
       
-      flags = gconf_address_flags(address);
+      flags = _gconf_address_flags(address);
 
       check(flags != NULL,
             "flags weren't extracted from `%s'",
             address);      
       
@@ -175,11 +175,11 @@ main (int argc, char** argv)
     }
 
   {
     gchar** flags;
 
-    flags = gconf_address_flags("xml::foobar");
+    flags = _gconf_address_flags("xml::foobar");
 
     check(flags == NULL,
           "flags were not NULL despite their absence");
 
     g_strfreev(flags);
Index: tests/testencode.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testencode.c,v
retrieving revision 1.7
diff -p -u -5 -r1.7 testencode.c
--- tests/testencode.c	10 Mar 2002 22:23:48 -0000	1.7
+++ tests/testencode.c	4 May 2006 11:21:04 -0000
@@ -138,13 +138,13 @@ check_quoting(void)
       gchar* quoted;
       gchar* unquoted;
       const gchar* end;
       GError* error = NULL;
       
-      quoted = gconf_quote_string(*testp);
+      quoted = _gconf_quote_string(*testp);
 
-      unquoted = gconf_unquote_string(quoted, &end, &error);
+      unquoted = _gconf_unquote_string(quoted, &end, &error);
 
       /*       print_parallel(*testp, unquoted); */
 
       check (error == NULL,
              "error parsing quoted string: %s",
Index: tests/testgconf.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testgconf.c,v
retrieving revision 1.26
diff -p -u -5 -r1.26 testgconf.c
--- tests/testgconf.c	22 Mar 2002 01:08:48 -0000	1.26
+++ tests/testgconf.c	4 May 2006 11:21:05 -0000
@@ -708,11 +708,11 @@ compare_lists(GConfValueType type, GSLis
       l1 = g_slist_next(l1);
       l2 = g_slist_next(l2);
     }
 
   check(l2 == NULL, "second list too long with list type %s",
-        gconf_value_type_to_string(type));
+        _gconf_value_type_to_string(type));
 }
 
 static void
 free_list(GConfValueType type, GSList* list)
 {
Index: tests/testschemas.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testschemas.c,v
retrieving revision 1.21
diff -p -u -5 -r1.21 testschemas.c
--- tests/testschemas.c	29 Mar 2002 06:27:13 -0000	1.21
+++ tests/testschemas.c	4 May 2006 11:21:05 -0000
@@ -309,25 +309,25 @@ check_one_schema(GConfEngine* conf, cons
       else
         {
           check (val != NULL, "Did not get a schema back after setting it");
 
           check (val->type == GCONF_VALUE_SCHEMA, "Got type %s back instead of schema",
-                 gconf_value_type_to_string (val->type));
+                 _gconf_value_type_to_string (val->type));
 
           gotten = gconf_value_get_schema (val);
           
           check (gconf_schema_get_type (schema) == gconf_schema_get_type (gotten),
                  "schema set/get pair: type `%s' set, `%s' got",
-                 gconf_value_type_to_string (gconf_schema_get_type (schema)),
-                 gconf_value_type_to_string (gconf_schema_get_type (gotten)));
+                 _gconf_value_type_to_string (gconf_schema_get_type (schema)),
+                 _gconf_value_type_to_string (gconf_schema_get_type (gotten)));
 
           /* If we set the schema for the current locale be sure we get it back */
-          if (null_safe_strcmp (gconf_current_locale (), gconf_schema_get_locale (schema)) == 0)
+          if (null_safe_strcmp (_gconf_current_locale (), gconf_schema_get_locale (schema)) == 0)
             {
-              check (null_safe_strcmp(gconf_current_locale(), gconf_schema_get_locale(gotten)) == 0,
+              check (null_safe_strcmp(_gconf_current_locale(), gconf_schema_get_locale(gotten)) == 0,
                      "schema set/get pair: locale `%s' set, `%s' got",
-                     gconf_current_locale(),
+                     _gconf_current_locale(),
                      NULL_SAFE (gconf_schema_get_locale (gotten)));
             }
               
           check (null_safe_strcmp (gconf_schema_get_short_desc (schema), gconf_schema_get_short_desc (gotten)) == 0,
                  "schema set/get pair: short_desc `%s' set, `%s' got",
@@ -356,17 +356,17 @@ check_one_schema(GConfEngine* conf, cons
                 check (set_default->type == GCONF_VALUE_INT,
                       "set default type is INT");
                 
                 check (set_default->type == got_default->type,
                        "schema set/get pair: default value type `%s' set, `%s' got",
-                       gconf_value_type_to_string(set_default->type),
-                       gconf_value_type_to_string(got_default->type));
+                       _gconf_value_type_to_string(set_default->type),
+                       _gconf_value_type_to_string(got_default->type));
                 
                 check (set_default->type == got_default->type,
                        "schema set/get pair: default value type `%s' set, `%s' got",
-                       gconf_value_type_to_string(set_default->type),
-                       gconf_value_type_to_string(got_default->type));
+                       _gconf_value_type_to_string(set_default->type),
+                       _gconf_value_type_to_string(got_default->type));
                 
                 check (gconf_value_get_int(set_default) == gconf_value_get_int(got_default),
                        "schema set/get pair: default value (int) `%d' set, `%d' got",
                        gconf_value_get_int(set_default), gconf_value_get_int(got_default));
               }
Index: tests/testbackend.c
===================================================================
RCS file: /export/cvs/head/gconf/tests/testbackend.c,v
retrieving revision 1.4
diff -p -u -5 -r1.4 testbackend.c
--- tests/testbackend.c	30 Mar 2004 15:32:05 -0000	1.4
+++ tests/testbackend.c	4 May 2006 11:21:05 -0000
@@ -417,11 +417,11 @@ set_list (GConfSource   *source,
   g_return_val_if_fail (list_type != GCONF_VALUE_INVALID, FALSE);
   g_return_val_if_fail (list_type != GCONF_VALUE_LIST, FALSE);
   g_return_val_if_fail (list_type != GCONF_VALUE_PAIR, FALSE);
   g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-  value_list = gconf_value_list_from_primitive_list (list_type, list, &tmp_err);
+  value_list = _gconf_value_list_from_primitive_list (list_type, list, &tmp_err);
 
   if (tmp_err)
     {
       g_propagate_error (err, tmp_err);
       return FALSE;
@@ -451,11 +451,11 @@ get_string (GConfSource *source,
   val = get_value (source, key, err);
 
   if (val)
     {
       g_assert (val->type == GCONF_VALUE_STRING);
-      s = gconf_value_steal_string (val);
+      s = _gconf_value_steal_string (val);
       gconf_value_free (val);
     }
   else
     {
       s = NULL;
@@ -556,11 +556,11 @@ get_list (GConfSource     *source,
   if (val == NULL)
     return NULL;
   else
     {
       /* This type-checks the value */
-      return gconf_value_list_to_primitive_list_destructive (val, list_type, err);
+      return _gconf_value_list_to_primitive_list_destructive (val, list_type, err);
     }
 }
 
 static void
 check_string_storage (GConfSource *source)
@@ -1040,11 +1040,11 @@ compare_lists (GConfValueType type, GSLi
       l1 = g_slist_next (l1);
       l2 = g_slist_next (l2);
     }
 
   check (l2 == NULL, "second list too long with list type %s",
-         gconf_value_type_to_string (type));
+         _gconf_value_type_to_string (type));
 }
 
 static void
 free_list (GConfValueType type, GSList* list)
 {
@@ -1263,11 +1263,11 @@ run_all_checks (const char *address)
   GConfSource *source;
   GError *error;
   Stats stats;
     
   error = NULL;
-  source = gconf_resolve_address (address, &error);
+  source = _gconf_resolve_address (address, &error);
   if (error != NULL)
     {
       g_printerr ("Could not resolve address: %s\n", error->message);
       g_error_free (error);
       exit (1);
@@ -1302,11 +1302,11 @@ run_all_checks (const char *address)
   
   check_bool_storage (source);
 
   sync_and_clear (source);
   
-  gconf_source_free (source);
+  _gconf_source_free (source);
 
   g_print ("\n\n");
 }
 
 int
@@ -1318,11 +1318,11 @@ main (int argc, char **argv)
       return 1;
     }
 
   setlocale (LC_ALL, "");
 
-  locales = (const char**) gconf_split_locale (gconf_current_locale ());
+  locales = (const char**) _gconf_split_locale (_gconf_current_locale ());
 
   run_all_checks (argv[1]);
   sync_enabled = TRUE;
   run_all_checks (argv[1]);
   
