[Gnucash-changes] Add glib key-value support for systems running
glib24.
David Hampton
hampton at cvs.gnucash.org
Fri Oct 7 18:12:48 EDT 2005
Log Message:
-----------
Add glib key-value support for systems running glib24.
Tags:
----
gnucash-gnome2-dev
Modified Files:
--------------
gnucash:
configure.in
gnucash/lib:
Makefile.am
Added Files:
-----------
gnucash/lib/glib26:
.cvsignore
Makefile.am
dummy.c
gkeyfile.c
gkeyfile.h
gutils26.c
gutils26.h
Revision Data
-------------
Index: configure.in
===================================================================
RCS file: /home/cvs/cvsroot/gnucash/configure.in,v
retrieving revision 1.359.2.65
retrieving revision 1.359.2.66
diff -Lconfigure.in -Lconfigure.in -u -r1.359.2.65 -r1.359.2.66
--- configure.in
+++ configure.in
@@ -138,6 +138,18 @@
AC_MSG_ERROR([Cannot find glib. Check config.log])
fi
+AC_MSG_CHECKING(for GLIB - version >= 2.6.0)
+if $PKG_CONFIG 'glib-2.0 >= 2.6.0'
+then
+ AC_MSG_RESULT(yes)
+ AC_DEFINE(HAVE_GLIB26,1,[System has glib 2.6.0 or better])
+ HAVE_GLIB26=yes
+else
+ AC_MSG_RESULT(no)
+fi
+AC_MSG_WARN(test "x$HAVE_GLIB26" = "xyes" )
+AM_CONDITIONAL(HAVE_GLIB26, test "x$HAVE_GLIB26" = "xyes" )
+
AC_CHECK_HEADERS(dlfcn.h dl.h utmp.h locale.h mcheck.h unistd.h wctype.h)
DL_LIB=
@@ -1218,6 +1230,7 @@
doc/examples/Makefile
intl-scm/Makefile
lib/Makefile
+ lib/glib26/Makefile
lib/guile-www/Makefile
lib/srfi/Makefile
lib/libc/Makefile
Index: Makefile.am
===================================================================
RCS file: /home/cvs/cvsroot/gnucash/lib/Makefile.am,v
retrieving revision 1.6.4.4
retrieving revision 1.6.4.5
diff -Llib/Makefile.am -Llib/Makefile.am -u -r1.6.4.4 -r1.6.4.5
--- lib/Makefile.am
+++ lib/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS = libc guile-www srfi goffice
+SUBDIRS = libc glib26 guile-www srfi goffice
EXTRA_DIST = README guppi-legend.patch
--- /dev/null
+++ lib/glib26/dummy.c
@@ -0,0 +1,6 @@
+void g_key_file_dumy_function (void);
+
+void
+g_key_file_dumy_function (void)
+{
+}
--- /dev/null
+++ lib/glib26/.cvsignore
@@ -0,0 +1,7 @@
+*.lo
+*.la
+.deps
+.libs
+.scm-links
+Makefile
+Makefile.in
--- /dev/null
+++ lib/glib26/gutils26.h
@@ -0,0 +1,183 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GLib Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __G_UTILS_26_H__
+#define __G_UTILS_26_H__
+
+#include <glib/gtypes.h>
+#include <stdarg.h>
+
+/* Start hacks to make this file compile with glib 2.4 */
+#define G_GNUC_MALLOC
+/* End hacks to make this file compile with glib 2.4 */
+
+G_BEGIN_DECLS
+
+#ifdef G_OS_WIN32
+
+/* On native Win32, directory separator is the backslash, and search path
+ * separator is the semicolon.
+ */
+#define G_DIR_SEPARATOR '\\'
+#define G_DIR_SEPARATOR_S "\\"
+#define G_IS_DIR_SEPARATOR(c) ((c) == G_DIR_SEPARATOR || (c) == '/')
+#define G_SEARCHPATH_SEPARATOR ';'
+#define G_SEARCHPATH_SEPARATOR_S ";"
+
+#else /* !G_OS_WIN32 */
+
+/* Unix */
+
+#define G_DIR_SEPARATOR '/'
+#define G_DIR_SEPARATOR_S "/"
+#define G_IS_DIR_SEPARATOR(c) ((c) == G_DIR_SEPARATOR)
+#define G_SEARCHPATH_SEPARATOR ':'
+#define G_SEARCHPATH_SEPARATOR_S ":"
+
+#endif /* !G_OS_WIN32 */
+
+/* Retrive static string info
+ */
+#ifdef G_OS_WIN32
+#define g_get_user_name g_get_user_name_utf8
+#define g_get_real_name g_get_real_name_utf8
+#define g_get_home_dir g_get_home_dir_utf8
+#define g_get_tmp_dir g_get_tmp_dir_utf8
+#endif
+
+G_CONST_RETURN gchar* g_get_user_name (void);
+G_CONST_RETURN gchar* g_get_real_name (void);
+G_CONST_RETURN gchar* g_get_home_dir (void);
+G_CONST_RETURN gchar* g_get_tmp_dir (void);
+gchar* g_get_prgname (void);
+void g_set_prgname (const gchar *prgname);
+G_CONST_RETURN gchar* g_get_application_name (void);
+void g_set_application_name (const gchar *application_name);
+
+G_CONST_RETURN gchar* g_get_user_data_dir (void);
+G_CONST_RETURN gchar* g_get_user_config_dir (void);
+G_CONST_RETURN gchar* g_get_user_cache_dir (void);
+G_CONST_RETURN gchar* G_CONST_RETURN * g_get_system_data_dirs (void);
+G_CONST_RETURN gchar* G_CONST_RETURN * g_get_system_config_dirs (void);
+
+G_CONST_RETURN gchar* G_CONST_RETURN * g_get_language_names (void);
+
+/* Miscellaneous utility functions
+ */
+gint g_snprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+ ...) G_GNUC_PRINTF (3, 4);
+gint g_vsnprintf (gchar *string,
+ gulong n,
+ gchar const *format,
+ va_list args);
+
+#ifndef G_DISABLE_DEPRECATED
+
+/* These two functions are deprecated and will be removed in the next
+ * major release of GLib. Use g_path_get_dirname/g_path_get_basename
+ * instead. Whatch out! The string returned by g_path_get_basename
+ * must be g_freed, while the string returned by g_basename must not.*/
+G_CONST_RETURN gchar* g_basename (const gchar *file_name);
+#define g_dirname g_path_get_dirname
+
+#endif /* G_DISABLE_DEPRECATED */
+
+#ifdef G_OS_WIN32
+#define g_get_current_dir g_get_current_dir_utf8
+#endif
+
+/* The returned strings are newly allocated with g_malloc() */
+gchar* g_get_current_dir (void);
+gchar* g_path_get_basename (const gchar *file_name) G_GNUC_MALLOC;
+gchar* g_path_get_dirname (const gchar *file_name) G_GNUC_MALLOC;
+
+/* Set the pointer at the specified location to NULL */
+void g_nullify_pointer (gpointer *nullify_location);
+
+/* Look for an executable in PATH, following execvp() rules */
+gchar* g_find_program_in_path (const gchar *program);
+
+
+/* Glib version.
+ * we prefix variable declarations so they can
+ * properly get exported in windows dlls.
+ */
+GLIB_VAR const guint glib_major_version;
+GLIB_VAR const guint glib_minor_version;
+GLIB_VAR const guint glib_micro_version;
+GLIB_VAR const guint glib_interface_age;
+GLIB_VAR const guint glib_binary_age;
+
+const gchar * glib_check_version (guint required_major,
+ guint required_minor,
+ guint required_micro);
+
+#define GLIB_CHECK_VERSION(major,minor,micro) \
+ (GLIB_MAJOR_VERSION > (major) || \
+ (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \
+ (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \
+ GLIB_MICRO_VERSION >= (micro)))
+
+G_END_DECLS
+
+/*
+ * On Windows, this macro defines a DllMain function that stores the
+ * actual DLL name that the code being compiled will be included in.
+ * STATIC should be empty or 'static'. DLL_NAME is the name of the
+ * (pointer to the) char array where the DLL name will be stored. If
+ * this is used, you must also include <windows.h>. If you need a more complex
+ * DLL entry point function, you cannot use this.
+ *
+ * On non-Windows platforms, expands to nothing.
+ */
+
+#ifndef G_PLATFORM_WIN32
+# define G_WIN32_DLLMAIN_FOR_DLL_NAME(static, dll_name)
+#else
+# define G_WIN32_DLLMAIN_FOR_DLL_NAME(static, dll_name) \
+static char *dll_name; \
+ \
+BOOL WINAPI \
+DllMain (HINSTANCE hinstDLL, \
+ DWORD fdwReason, \
+ LPVOID lpvReserved) \
+{ \
+ char bfr[1000]; \
+ switch (fdwReason) \
+ { \
+ case DLL_PROCESS_ATTACH: \
+ GetModuleFileName ((HMODULE) hinstDLL, bfr, sizeof (bfr)); \
+ dll_name = g_path_get_basename (bfr); \
+ break; \
+ } \
+ \
+ return TRUE; \
+}
+#endif /* G_PLATFORM_WIN32 */
+
+#endif /* __G_UTILS_26_H__ */
--- /dev/null
+++ lib/glib26/gkeyfile.c
@@ -0,0 +1,3312 @@
+/* gkeyfile.c - key file parser
+ *
+ * Copyright 2004 Red Hat, Inc.
+ *
+ * Written by Ray Strode <rstrode at redhat.com>
+ * Matthias Clasen <mclasen at redhat.com>
+ *
+ * GLib is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * GLib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GLib; see the file COPYING.LIB. If not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gkeyfile.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef G_OS_WIN32
+#include <io.h>
+
+#ifndef S_ISREG
+#define S_ISREG(mode) ((mode)&_S_IFREG)
+#endif
+
+#endif /* G_OS_WIN23 */
+
+/* Start hacks to make this file compile with glib 2.4 */
+#include "gutils26.h"
+#include <glib.h>
+#define g_open(X,Y,Z) open(X,Y,Z)
+#define _(X) X
+/* End hacks to make this file compile with glib 2.4 */
+
+#if 0
+#include "gconvert.h"
+#include "gdataset.h"
+#include "gerror.h"
+#include "gfileutils.h"
+#include "ghash.h"
+#include "glibintl.h"
+#include "glist.h"
+#include "gslist.h"
+#include "gmem.h"
+#include "gmessages.h"
+#include "gstdio.h"
+#include "gstring.h"
+#include "gstrfuncs.h"
+#include "gutils.h"
+
+#include "galias.h"
+#endif
+
+typedef struct _GKeyFileGroup GKeyFileGroup;
+
+struct _GKeyFile
+{
+ GList *groups;
+
+ GKeyFileGroup *start_group;
+ GKeyFileGroup *current_group;
+
+ GString *parse_buffer; /* Holds up to one line of not-yet-parsed data */
+
+ /* Used for sizing the output buffer during serialization
+ */
+ gsize approximate_size;
+
+ gchar list_separator;
+
+ GKeyFileFlags flags;
+};
+
+typedef struct _GKeyFileKeyValuePair GKeyFileKeyValuePair;
+
+struct _GKeyFileGroup
+{
+ const gchar *name; /* NULL for above first group (which will be comments) */
+
+ GKeyFileKeyValuePair *comment; /* Special comment that is stuck to the top of a group */
+
+ GList *key_value_pairs;
+
+ /* Used in parallel with key_value_pairs for
+ * increased lookup performance
+ */
+ GHashTable *lookup_map;
+};
+
+struct _GKeyFileKeyValuePair
+{
+ gchar *key; /* NULL for comments */
+ gchar *value;
+};
+
+static gint find_file_in_data_dirs (const gchar *file,
+ gchar **output_file,
+ gchar ***data_dirs,
+ GError **error);
+static gboolean g_key_file_load_from_fd (GKeyFile *key_file,
+ gint fd,
+ GKeyFileFlags flags,
+ GError **error);
+static GList *g_key_file_lookup_group_node (GKeyFile *key_file,
+ const gchar *group_name);
+static GKeyFileGroup *g_key_file_lookup_group (GKeyFile *key_file,
+ const gchar *group_name);
+
+static GList *g_key_file_lookup_key_value_pair_node (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key);
+static GKeyFileKeyValuePair *g_key_file_lookup_key_value_pair (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key);
+
+static void g_key_file_remove_group_node (GKeyFile *key_file,
+ GList *group_node);
+static void g_key_file_remove_key_value_pair_node (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ GList *pair_node);
+
+static void g_key_file_add_key (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key,
+ const gchar *value);
+static void g_key_file_add_group (GKeyFile *key_file,
+ const gchar *group_name);
+static void g_key_file_key_value_pair_free (GKeyFileKeyValuePair *pair);
+static gboolean g_key_file_line_is_comment (const gchar *line);
+static gboolean g_key_file_line_is_group (const gchar *line);
+static gboolean g_key_file_line_is_key_value_pair (const gchar *line);
+static gchar *g_key_file_parse_value_as_string (GKeyFile *key_file,
+ const gchar *value,
+ GSList **separators,
+ GError **error);
+static gchar *g_key_file_parse_string_as_value (GKeyFile *key_file,
+ const gchar *string,
+ gboolean escape_separator);
+static gint g_key_file_parse_value_as_integer (GKeyFile *key_file,
+ const gchar *value,
+ GError **error);
+static gchar *g_key_file_parse_integer_as_value (GKeyFile *key_file,
+ gint value);
+static gboolean g_key_file_parse_value_as_boolean (GKeyFile *key_file,
+ const gchar *value,
+ GError **error);
+static gchar *g_key_file_parse_boolean_as_value (GKeyFile *key_file,
+ gboolean value);
+static gchar *g_key_file_parse_value_as_comment (GKeyFile *key_file,
+ const gchar *value);
+static gchar *g_key_file_parse_comment_as_value (GKeyFile *key_file,
+ const gchar *comment);
+static void g_key_file_parse_key_value_pair (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error);
+static void g_key_file_parse_comment (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error);
+static void g_key_file_parse_group (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error);
+static gchar *key_get_locale (const gchar *key);
+static void g_key_file_parse_data (GKeyFile *key_file,
+ const gchar *data,
+ gsize length,
+ GError **error);
+static void g_key_file_flush_parse_buffer (GKeyFile *key_file,
+ GError **error);
+
+
+/**
+ * g_strv_length:
+ * @str_array: a %NULL-terminated array of strings.
+ *
+ * Returns the length of the given %NULL-terminated
+ * string array @str_array.
+ *
+ * Return value: length of @str_array.
+ *
+ * From the file gstrfuncs.c
+ *
+ * Since: 2.6
+ **/
+static guint
+g_strv_length (gchar **str_array)
+{
+ guint i = 0;
+
+ g_return_val_if_fail (str_array != NULL, 0);
+
+ while (str_array[i])
+ ++i;
+
+ return i;
+}
+
+GQuark
+g_key_file_error_quark (void)
+{
+ static GQuark error_quark = 0;
+
+ if (error_quark == 0)
+ error_quark = g_quark_from_static_string ("g-key-file-error-quark");
+
+ return error_quark;
+}
+
+static void
+g_key_file_init (GKeyFile *key_file)
+{
+ key_file->current_group = g_new0 (GKeyFileGroup, 1);
+ key_file->groups = g_list_prepend (NULL, key_file->current_group);
+ key_file->start_group = NULL;
+ key_file->parse_buffer = g_string_sized_new (128);
+ key_file->approximate_size = 0;
+ key_file->list_separator = ';';
+ key_file->flags = 0;
+}
+
+static void
+g_key_file_clear (GKeyFile *key_file)
+{
+ GList *tmp, *group_node;
+
+ if (key_file->parse_buffer)
+ g_string_free (key_file->parse_buffer, TRUE);
+
+ tmp = key_file->groups;
+ while (tmp != NULL)
+ {
+ group_node = tmp;
+ tmp = tmp->next;
+ g_key_file_remove_group_node (key_file, group_node);
+ }
+
+ g_assert (key_file->groups == NULL);
+}
+
+
+/**
+ * g_key_file_new:
+ *
+ * Creates a new empty #GKeyFile object. Use g_key_file_load_from_file(),
+ * g_key_file_load_from_data() or g_key_file_load_from_data_dirs() to
+ * read an existing key file.
+ *
+ * Return value: an empty #GKeyFile.
+ *
+ * Since: 2.6
+ **/
+GKeyFile *
+g_key_file_new (void)
+{
+ GKeyFile *key_file;
+
+ key_file = g_new0 (GKeyFile, 1);
+ g_key_file_init (key_file);
+
+ return key_file;
+}
+
+/**
+ * g_key_file_set_list_separator:
+ * @key_file: a #GKeyFile
+ * @separator: the separator
+ *
+ * Sets the character which is used to separate
+ * values in lists. Typically ';' or ',' are used
+ * as separators. The default list separator is ';'.
+ *
+ * Since: 2.6
+ */
+void
+g_key_file_set_list_separator (GKeyFile *key_file,
+ gchar separator)
+{
+ key_file->list_separator = separator;
+}
+
+
+/* Iterates through all the directories in *dirs trying to
+ * open file. When it successfully locates and opens a file it
+ * returns the file descriptor to the open file. It also
+ * outputs the absolute path of the file in output_file and
+ * leaves the unchecked directories in *dirs.
+ */
+static gint
+find_file_in_data_dirs (const gchar *file,
+ gchar **output_file,
+ gchar ***dirs,
+ GError **error)
+{
+ gchar **data_dirs, *data_dir, *path;
+ gint fd;
+
+ path = NULL;
+ fd = -1;
+
+ if (dirs == NULL)
+ return fd;
+
+ data_dirs = *dirs;
+
+ while (data_dirs && (data_dir = *data_dirs) && fd < 0)
+ {
+ gchar *candidate_file, *sub_dir;
+
+ candidate_file = (gchar *) file;
+ sub_dir = g_strdup ("");
+ while (candidate_file != NULL && fd < 0)
+ {
+ gchar *p;
+
+ path = g_build_filename (data_dir, sub_dir,
+ candidate_file, NULL);
+
+ fd = g_open (path, O_RDONLY, 0);
+
+ if (fd < 0)
+ {
+ g_free (path);
+ path = NULL;
+ }
+
+ candidate_file = strchr (candidate_file, '-');
+
+ if (candidate_file == NULL)
+ break;
+
+ candidate_file++;
+
+ g_free (sub_dir);
+ sub_dir = g_strndup (file, candidate_file - file - 1);
+
+ for (p = sub_dir; *p != '\0'; p++)
+ {
+ if (*p == '-')
+ *p = G_DIR_SEPARATOR;
+ }
+ }
+ g_free (sub_dir);
+ data_dirs++;
+ }
+
+ *dirs = data_dirs;
+
+ if (fd < 0)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_NOT_FOUND,
+ _("Valid key file could not be "
+ "found in data dirs"));
+ }
+
+ if (output_file != NULL && fd > 0)
+ *output_file = g_strdup (path);
+
+ g_free (path);
+
+ return fd;
+}
+
+static gboolean
+g_key_file_load_from_fd (GKeyFile *key_file,
+ gint fd,
+ GKeyFileFlags flags,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gsize bytes_read;
+ struct stat stat_buf;
+ gchar read_buf[4096];
+
+ if (fstat (fd, &stat_buf) < 0)
+ {
+ g_set_error (error, G_FILE_ERROR,
+ g_file_error_from_errno (errno),
+ "%s", g_strerror (errno));
+ return FALSE;
+ }
+
+ if (!S_ISREG (stat_buf.st_mode))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_PARSE,
+ _("Not a regular file"));
+ return FALSE;
+ }
+
+ if (stat_buf.st_size == 0)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_PARSE,
+ _("File is empty"));
+ return FALSE;
+ }
+
+ if (key_file->approximate_size > 0)
+ {
+ g_key_file_clear (key_file);
+ g_key_file_init (key_file);
+ }
+ key_file->flags = flags;
+
+ bytes_read = 0;
+ do
+ {
+ bytes_read = read (fd, read_buf, 4096);
+
+ if (bytes_read == 0) /* End of File */
+ break;
+
+ if (bytes_read < 0)
+ {
+ if (errno == EINTR || errno == EAGAIN)
+ continue;
+
+ g_set_error (error, G_FILE_ERROR,
+ g_file_error_from_errno (errno),
+ "%s", g_strerror (errno));
+ return FALSE;
+ }
+
+ g_key_file_parse_data (key_file,
+ read_buf, bytes_read,
+ &key_file_error);
+ }
+ while (!key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ g_key_file_flush_parse_buffer (key_file, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * g_key_file_load_from_file:
+ * @key_file: an empty #GKeyFile struct
+ * @file: the path of a filename to load, in the GLib file name encoding
+ * @flags: flags from #GKeyFileFlags
+ * @error: return location for a #GError, or %NULL
+ *
+ * Loads a key file into an empty #GKeyFile structure.
+ * If the file could not be loaded then %error is set to
+ * either a #GFileError or #GKeyFileError.
+ *
+ * Return value: %TRUE if a key file could be loaded, %FALSE othewise
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_load_from_file (GKeyFile *key_file,
+ const gchar *file,
+ GKeyFileFlags flags,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gint fd;
+
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (file != NULL, FALSE);
+
+ fd = g_open (file, O_RDONLY, 0);
+
+ if (fd < 0)
+ {
+ g_set_error (error, G_FILE_ERROR,
+ g_file_error_from_errno (errno),
+ "%s", g_strerror (errno));
+ return FALSE;
+ }
+
+ g_key_file_load_from_fd (key_file, fd, flags, &key_file_error);
+ close (fd);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * g_key_file_load_from_data:
+ * @key_file: an empty #GKeyFile struct
+ * @data: key file loaded in memory.
+ * @length: the length of @data in bytes
+ * @flags: flags from #GKeyFileFlags
+ * @error: return location for a #GError, or %NULL
+ *
+ * Loads a key file from memory into an empty #GKeyFile structure. If
+ * the object cannot be created then %error is set to a
+ * #GKeyFileError.
+ *
+ * Return value: %TRUE if a key file could be loaded, %FALSE othewise
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_load_from_data (GKeyFile *key_file,
+ const gchar *data,
+ gsize length,
+ GKeyFileFlags flags,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+ g_return_val_if_fail (length != 0, FALSE);
+
+ if (length == (gsize)-1)
+ length = strlen (data);
+
+ if (key_file->approximate_size > 0)
+ {
+ g_key_file_clear (key_file);
+ g_key_file_init (key_file);
+ }
+ key_file->flags = flags;
+
+ g_key_file_parse_data (key_file, data, length, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ g_key_file_flush_parse_buffer (key_file, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * g_key_file_load_from_data_dirs:
+ * @key_file: an empty #GKeyFile struct
+ * @file: a relative path to a filename to open and parse
+ * @full_path: return location for a string containing the full path
+ * of the file, or %NULL
+ * @flags: flags from #GKeyFileFlags
+ * @error: return location for a #GError, or %NULL
+ *
+ * This function looks for a key file named @file in the paths
+ * returned from g_get_user_data_dir() and g_get_system_data_dirs(),
+ * loads the file into @key_file and returns the file's full path in
+ * @full_path. If the file could not be loaded then an %error is
+ * set to either a #GFileError or #GKeyFileError.
+ *
+ * Return value: %TRUE if a key file could be loaded, %FALSE othewise
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_load_from_data_dirs (GKeyFile *key_file,
+ const gchar *file,
+ gchar **full_path,
+ GKeyFileFlags flags,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gchar **all_data_dirs, **data_dirs;
+ const gchar * user_data_dir;
+ const gchar * const * system_data_dirs;
+ gsize i, j;
+ gchar *output_path;
+ gint fd;
+ gboolean found_file;
+
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (!g_path_is_absolute (file), FALSE);
+
+ user_data_dir = g_get_user_data_dir ();
+ system_data_dirs = g_get_system_data_dirs ();
+ all_data_dirs = g_new0 (gchar *, g_strv_length ((gchar **)system_data_dirs) + 2);
+
+ i = 0;
+ all_data_dirs[i++] = g_strdup (user_data_dir);
+
+ j = 0;
+ while (system_data_dirs[j] != NULL)
+ all_data_dirs[i++] = g_strdup (system_data_dirs[j++]);
+
+ found_file = FALSE;
+ data_dirs = all_data_dirs;
+ while (*data_dirs != NULL && !found_file)
+ {
+ fd = find_file_in_data_dirs (file, &output_path, &data_dirs,
+ &key_file_error);
+
+ if (fd < 0)
+ {
+ if (key_file_error)
+ g_propagate_error (error, key_file_error);
+ break;
+ }
+
+ found_file = g_key_file_load_from_fd (key_file, fd, flags,
+ &key_file_error);
+ close (fd);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ g_free (output_path);
+ break;
+ }
+
+ if (full_path)
+ *full_path = output_path;
+ }
+
+ g_strfreev (all_data_dirs);
+ return found_file;
+}
+
+/**
+ * g_key_file_free:
+ * @key_file: a #GKeyFile
+ *
+ * Frees a #GKeyFile.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_free (GKeyFile *key_file)
+{
+ g_return_if_fail (key_file != NULL);
+
+ g_key_file_clear (key_file);
+ g_free (key_file);
+}
+
+/* If G_KEY_FILE_KEEP_TRANSLATIONS is not set, only returns
+ * true for locales that match those in g_get_language_names().
+ */
+static gboolean
+g_key_file_locale_is_interesting (GKeyFile *key_file,
+ const gchar *locale)
+{
+ const gchar * const * current_locales;
+ gsize i;
+
+ if (key_file->flags & G_KEY_FILE_KEEP_TRANSLATIONS)
+ return TRUE;
+
+ current_locales = g_get_language_names ();
+
+ for (i = 0; current_locales[i] != NULL; i++)
+ {
+ if (g_ascii_strcasecmp (current_locales[i], locale) == 0)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+g_key_file_parse_line (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error)
+{
+ GError *parse_error = NULL;
+ gchar *line_start;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (line != NULL);
+
+ line_start = (gchar *) line;
+ while (g_ascii_isspace (*line_start))
+ line_start++;
+
+ if (g_key_file_line_is_comment (line_start))
+ g_key_file_parse_comment (key_file, line, length, &parse_error);
+ else if (g_key_file_line_is_group (line_start))
+ g_key_file_parse_group (key_file, line_start,
+ length - (line_start - line),
+ &parse_error);
+ else if (g_key_file_line_is_key_value_pair (line_start))
+ g_key_file_parse_key_value_pair (key_file, line_start,
+ length - (line_start - line),
+ &parse_error);
+ else
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_PARSE,
+ _("Key file contains line '%s' which is not "
+ "a key-value pair, group, or comment"), line);
+ return;
+ }
+
+ if (parse_error)
+ g_propagate_error (error, parse_error);
+}
+
+static void
+g_key_file_parse_comment (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error)
+{
+ GKeyFileKeyValuePair *pair;
+
+ if (!(key_file->flags & G_KEY_FILE_KEEP_COMMENTS))
+ return;
+
+ g_assert (key_file->current_group != NULL);
+
+ pair = g_new0 (GKeyFileKeyValuePair, 1);
+
+ pair->key = NULL;
+ pair->value = g_strndup (line, length);
+
+ key_file->current_group->key_value_pairs =
+ g_list_prepend (key_file->current_group->key_value_pairs, pair);
+}
+
+static void
+g_key_file_parse_group (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error)
+{
+ gchar *group_name;
+ const gchar *group_name_start, *group_name_end;
+
+ /* advance past opening '['
+ */
+ group_name_start = line + 1;
+ group_name_end = line + length - 1;
+
+ while (*group_name_end != ']')
+ group_name_end--;
+
+ group_name = g_strndup (group_name_start,
+ group_name_end - group_name_start);
+
+ g_key_file_add_group (key_file, group_name);
+ g_free (group_name);
+}
+
+static void
+g_key_file_parse_key_value_pair (GKeyFile *key_file,
+ const gchar *line,
+ gsize length,
+ GError **error)
+{
+ gchar *key, *value, *key_end, *value_start, *locale;
+ gsize key_len, value_len;
+
+ if (key_file->current_group == NULL || key_file->current_group->name == NULL)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not start with a group"));
+ return;
+ }
+
+ key_end = value_start = strchr (line, '=');
+
+ g_assert (key_end != NULL);
+
+ key_end--;
+ value_start++;
+
+ /* Pull the key name from the line (chomping trailing whitespace)
+ */
+ while (g_ascii_isspace (*key_end))
+ key_end--;
+
+ key_len = key_end - line + 2;
+
+ g_assert (key_len <= length);
+
+ key = g_strndup (line, key_len - 1);
+
+ /* Pull the value from the line (chugging leading whitespace)
+ */
+ while (g_ascii_isspace (*value_start))
+ value_start++;
+
+ value_len = line + length - value_start + 1;
+
+ value = g_strndup (value_start, value_len);
+
+ g_assert (key_file->start_group != NULL);
+
+ if (key_file->current_group
+ && key_file->current_group->name
+ && strcmp (key_file->start_group->name,
+ key_file->current_group->name) == 0
+ && strcmp (key, "Encoding") == 0)
+ {
+ if (g_ascii_strcasecmp (value, "UTF-8") != 0)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
+ _("Key file contains unsupported encoding '%s'"), value);
+
+ g_free (key);
+ g_free (value);
+ return;
+ }
+ }
+
+ /* Is this key a translation? If so, is it one that we care about?
+ */
+ locale = key_get_locale (key);
+
+ if (locale == NULL || g_key_file_locale_is_interesting (key_file, locale))
+ g_key_file_add_key (key_file, key_file->current_group, key, value);
+
+ g_free (locale);
+ g_free (key);
+ g_free (value);
+}
+
+static gchar *
+key_get_locale (const gchar *key)
+{
+ gchar *locale;
+
+ locale = g_strrstr (key, "[");
+
+ if (locale && strlen (locale) <= 2)
+ locale = NULL;
+
+ if (locale)
+ locale = g_strndup (locale + 1, strlen (locale) - 2);
+
+ return locale;
+}
+
+static void
+g_key_file_parse_data (GKeyFile *key_file,
+ const gchar *data,
+ gsize length,
+ GError **error)
+{
+ GError *parse_error;
+ gsize i;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (data != NULL);
+
+ parse_error = NULL;
+
+ for (i = 0; i < length; i++)
+ {
+ if (data[i] == '\n')
+ {
+ if (i > 0 && data[i - 1] == '\r')
+ g_string_erase (key_file->parse_buffer,
+ key_file->parse_buffer->len - 1,
+ 1);
+
+ /* When a newline is encountered flush the parse buffer so that the
+ * line can be parsed. Note that completely blank lines won't show
+ * up in the parse buffer, so they get parsed directly.
+ */
+ if (key_file->parse_buffer->len > 0)
+ g_key_file_flush_parse_buffer (key_file, &parse_error);
+ else
+ g_key_file_parse_comment (key_file, "", 1, &parse_error);
+
+ if (parse_error)
+ {
+ g_propagate_error (error, parse_error);
+ return;
+ }
+ }
+ else
+ g_string_append_c (key_file->parse_buffer, data[i]);
+ }
+
+ key_file->approximate_size += length;
+}
+
+static void
+g_key_file_flush_parse_buffer (GKeyFile *key_file,
+ GError **error)
+{
+ GError *file_error = NULL;
+
+ g_return_if_fail (key_file != NULL);
+
+ file_error = NULL;
+
+ if (key_file->parse_buffer->len > 0)
+ {
+ g_key_file_parse_line (key_file, key_file->parse_buffer->str,
+ key_file->parse_buffer->len,
+ &file_error);
+ g_string_erase (key_file->parse_buffer, 0, -1);
+
+ if (file_error)
+ {
+ g_propagate_error (error, file_error);
+ return;
+ }
+ }
+}
+
+/**
+ * g_key_file_to_data:
+ * @key_file: a #GKeyFile
+ * @length: return location for the length of the
+ * returned string, or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * This function outputs @key_file as a string.
+ *
+ * Return value: a newly allocated string holding
+ * the contents of the #GKeyFile
+ *
+ * Since: 2.6
+ **/
+gchar *
+g_key_file_to_data (GKeyFile *key_file,
+ gsize *length,
+ GError **error)
+{
+ GString *data_string;
+ gchar *data;
+ GList *group_node, *key_file_node;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+
+ data_string = g_string_sized_new (2 * key_file->approximate_size);
+
+ for (group_node = g_list_last (key_file->groups);
+ group_node != NULL;
+ group_node = group_node->prev)
+ {
+ GKeyFileGroup *group;
+
+ group = (GKeyFileGroup *) group_node->data;
+
+ if (group->comment != NULL)
+ g_string_append_printf (data_string, "%s\n", group->comment->value);
+ if (group->name != NULL)
+ g_string_append_printf (data_string, "[%s]\n", group->name);
+
+ for (key_file_node = g_list_last (group->key_value_pairs);
+ key_file_node != NULL;
+ key_file_node = key_file_node->prev)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) key_file_node->data;
+
+ if (pair->key != NULL)
+ g_string_append_printf (data_string, "%s=%s\n", pair->key, pair->value);
+ else
+ g_string_append_printf (data_string, "%s\n", pair->value);
+ }
+ }
+
+ if (length)
+ *length = data_string->len;
+
+ data = data_string->str;
+
+ g_string_free (data_string, FALSE);
+
+ return data;
+}
+
+/**
+ * g_key_file_get_keys:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @length: return location for the number of keys returned, or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * Returns all keys for the group name @group_name. The array of
+ * returned keys will be %NULL-terminated, so @length may
+ * optionally be %NULL. In the event that the @group_name cannot
+ * be found, %NULL is returned and @error is set to
+ * #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+ *
+ * Return value: a newly-allocated %NULL-terminated array of
+ * strings. Use g_strfreev() to free it.
+ *
+ * Since: 2.6
+ **/
+gchar **
+g_key_file_get_keys (GKeyFile *key_file,
+ const gchar *group_name,
+ gsize *length,
+ GError **error)
+{
+ GKeyFileGroup *group;
+ GList *tmp;
+ gchar **keys;
+ gsize i, num_keys;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+
+ group = g_key_file_lookup_group (key_file, group_name);
+
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+ return NULL;
+ }
+
+ num_keys = g_list_length (group->key_value_pairs);
+
+ keys = (gchar **) g_new0 (gchar **, num_keys + 1);
+
+ tmp = group->key_value_pairs;
+ for (i = 1; i <= num_keys; i++)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) tmp->data;
+ keys[num_keys - i] = g_strdup (pair->key);
+
+ tmp = tmp->next;
+ }
+ keys[num_keys] = NULL;
+
+ if (length)
+ *length = num_keys;
+
+ return keys;
+}
+
+/**
+ * g_key_file_get_start_group:
+ * @key_file: a #GKeyFile
+ *
+ * Returns the name of the start group of the file.
+ *
+ * Return value: The start group of the key file.
+ *
+ * Since: 2.6
+ **/
+gchar *
+g_key_file_get_start_group (GKeyFile *key_file)
+{
+ g_return_val_if_fail (key_file != NULL, NULL);
+
+ if (key_file->start_group)
+ return g_strdup (key_file->start_group->name);
+
+ return NULL;
+}
+
+/**
+ * g_key_file_get_groups:
+ * @key_file: a #GKeyFile
+ * @length: return location for the number of returned groups, or %NULL
+ *
+ * Returns all groups in the key file loaded with @key_file. The
+ * array of returned groups will be %NULL-terminated, so @length may
+ * optionally be %NULL.
+ *
+ * Return value: a newly-allocated %NULL-terminated array of strings.
+ * Use g_strfreev() to free it.
+ * Since: 2.6
+ **/
+gchar **
+g_key_file_get_groups (GKeyFile *key_file,
+ gsize *length)
+{
+ GList *group_node;
+ gchar **groups;
+ gsize i, num_groups;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+
+ num_groups = g_list_length (key_file->groups);
+
+ g_assert (num_groups > 0);
+
+ /* Only need num_groups instead of num_groups + 1
+ * because the first group of the file (last in the
+ * list) is always the comment group at the top,
+ * which we skip
+ */
+ groups = (gchar **) g_new0 (gchar **, num_groups);
+
+ group_node = g_list_last (key_file->groups);
+
+ g_assert (((GKeyFileGroup *) group_node->data)->name == NULL);
+
+ i = 0;
+ for (group_node = group_node->prev;
+ group_node != NULL;
+ group_node = group_node->prev)
+ {
+ GKeyFileGroup *group;
+
+ group = (GKeyFileGroup *) group_node->data;
+
+ g_assert (group->name != NULL);
+
+ groups[i++] = g_strdup (group->name);
+ }
+ groups[i] = NULL;
+
+ if (length)
+ *length = i;
+
+ return groups;
+}
+
+/**
+ * g_key_file_get_value:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @error: return location for a #GError, or %NULL
+ *
+ * Returns the value associated with @key under @group_name.
+ *
+ * In the event the key cannot be found, %NULL is returned and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the
+ * event that the @group_name cannot be found, %NULL is returned
+ * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+ *
+ * Return value: a newly allocated string or %NULL if the specified
+ * key cannot be found.
+ *
+ * Since: 2.6
+ **/
+gchar *
+g_key_file_get_value (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GKeyFileGroup *group;
+ GKeyFileKeyValuePair *pair;
+ gchar *value = NULL;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ group = g_key_file_lookup_group (key_file, group_name);
+
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+ return NULL;
+ }
+
+ pair = g_key_file_lookup_key_value_pair (key_file, group, key);
+
+ if (pair)
+ value = g_strdup (pair->value);
+ else
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_KEY_NOT_FOUND,
+ _("Key file does not have key '%s'"), key);
+
+ return value;
+}
+
+/**
+ * g_key_file_set_value:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @value: a string
+ *
+ * Associates a new value with @key under @group_name. If @key
+ * cannot be found then it is created. If @group_name cannot be
+ * found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_value (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *value)
+{
+ GKeyFileGroup *group;
+ GKeyFileKeyValuePair *pair;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (value != NULL);
+
+ group = g_key_file_lookup_group (key_file, group_name);
+
+ if (!group)
+ {
+ g_key_file_add_group (key_file, group_name);
+ group = (GKeyFileGroup *) key_file->groups->data;
+
+ g_key_file_add_key (key_file, group, key, value);
+ }
+ else
+ {
+ pair = g_key_file_lookup_key_value_pair (key_file, group, key);
+
+ if (!pair)
+ g_key_file_add_key (key_file, group, key, value);
+ else
+ {
+ g_free (pair->value);
+ pair->value = g_strdup (value);
+ }
+ }
+}
+
+/**
+ * g_key_file_get_string:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @error: return location for a #GError, or %NULL
+ *
+ * Returns the value associated with @key under @group_name.
+ *
+ * In the event the key cannot be found, %NULL is returned and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the
+ * event that the @group_name cannot be found, %NULL is returned
+ * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+ *
+ * Return value: a newly allocated string or %NULL if the specified
+ * key cannot be found.
+ *
+ * Since: 2.6
+ **/
+gchar *
+g_key_file_get_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ gchar *value, *string_value;
+ GError *key_file_error;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ key_file_error = NULL;
+
+ value = g_key_file_get_value (key_file, group_name, key, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return NULL;
+ }
+
+ if (!g_utf8_validate (value, -1, NULL))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
+ _("Key file contains key '%s' with value '%s' "
+ "which is not UTF-8"), key, value);
+ g_free (value);
+ return NULL;
+ }
+
+ string_value = g_key_file_parse_value_as_string (key_file, value, NULL,
+ &key_file_error);
+ g_free (value);
+
+ if (key_file_error)
+ {
+ if (g_error_matches (key_file_error,
+ G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains key '%s' "
+ "which has value that cannot be interpreted."),
+ key);
+ g_error_free (key_file_error);
+ }
+ else
+ g_propagate_error (error, key_file_error);
+ }
+
+ return string_value;
+}
+
+/**
+ * g_key_file_set_string:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @string: a string
+ *
+ * Associates a new string value with @key under @group_name. If
+ * @key cannot be found then it is created. If @group_name
+ * cannot be found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *string)
+{
+ gchar *value;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (string != NULL);
+
+ value = g_key_file_parse_string_as_value (key_file, string, FALSE);
+ g_key_file_set_value (key_file, group_name, key, value);
+ g_free (value);
+}
+
+/**
+ * g_key_file_get_string_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @length: return location for the number of returned strings, or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * Returns the values associated with @key under @group_name.
+ *
+ * In the event the key cannot be found, %NULL is returned and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the
+ * event that the @group_name cannot be found, %NULL is returned
+ * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+ *
+ * Return value: a %NULL-terminated string array or %NULL if the specified
+ * key cannot be found. The array should be freed with g_strfreev().
+ *
+ * Since: 2.6
+ **/
+gchar **
+g_key_file_get_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gchar *value, *string_value, **values;
+ gint i, len;
+ GSList *p, *pieces = NULL;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ value = g_key_file_get_value (key_file, group_name, key, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return NULL;
+ }
+
+ if (!g_utf8_validate (value, -1, NULL))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
+ _("Key file contains key '%s' with value '%s' "
+ "which is not UTF-8"), key, value);
+ g_free (value);
+ return NULL;
+ }
+
+ string_value = g_key_file_parse_value_as_string (key_file, value, &pieces, &key_file_error);
+ g_free (value);
+ g_free (string_value);
+
+ if (key_file_error)
+ {
+ if (g_error_matches (key_file_error,
+ G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains key '%s' "
+ "which has value that cannot be interpreted."),
+ key);
+ g_error_free (key_file_error);
+ }
+ else
+ g_propagate_error (error, key_file_error);
+ }
+
+ len = g_slist_length (pieces);
+ values = g_new0 (gchar *, len + 1);
+ for (p = pieces, i = 0; p; p = p->next)
+ values[i++] = p->data;
+ values[len] = NULL;
+
+ g_slist_free (pieces);
+
+ if (length)
+ *length = len;
+
+ return values;
+}
+
+/**
+ * g_key_file_set_string_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @list: an array of locale string values
+ * @length: number of locale string values in @list
+ *
+ * Associates a list of string values for @key under @group_name.
+ * If @key cannot be found then it is created. If @group_name
+ * cannot be found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar * const list[],
+ gsize length)
+{
+ GString *value_list;
+ gsize i;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (list != NULL);
+
+ value_list = g_string_sized_new (length * 128);
+ for (i = 0; list[i] != NULL && i < length; i++)
+ {
+ gchar *value;
+
+ value = g_key_file_parse_string_as_value (key_file, list[i], TRUE);
+ g_string_append (value_list, value);
+ g_string_append_c (value_list, key_file->list_separator);
+
+ g_free (value);
+ }
+
+ g_key_file_set_value (key_file, group_name, key, value_list->str);
+ g_string_free (value_list, TRUE);
+}
+
+/**
+ * g_key_file_set_locale_string:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @locale: a locale
+ * @string: a string
+ *
+ * Associates a string value for @key and @locale under
+ * @group_name. If the translation for @key cannot be found
+ * then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_locale_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ const gchar *string)
+{
+ gchar *full_key, *value;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (locale != NULL);
+ g_return_if_fail (string != NULL);
+
+ value = g_key_file_parse_string_as_value (key_file, string, FALSE);
+ full_key = g_strdup_printf ("%s[%s]", key, locale);
+ g_key_file_set_value (key_file, group_name, full_key, value);
+ g_free (full_key);
+ g_free (value);
+}
+
+extern GSList *_g_compute_locale_variants (const gchar *locale);
+
+/**
+ * g_key_file_get_locale_string:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @locale: a locale or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * Returns the value associated with @key under @group_name
+ * translated in the given @locale if available. If @locale is
+ * %NULL then the current locale is assumed.
+ *
+ * If @key cannot be found then %NULL is returned and @error is set to
+ * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
+ * with @key cannot be interpreted or no suitable translation can
+ * be found then the untranslated value is returned.
+ *
+ * Return value: a newly allocated string or %NULL if the specified key
+ * cannot be found.
+ *
+ * Since: 2.6
+ **/
+gchar *
+g_key_file_get_locale_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ GError **error)
+{
+ gchar *candidate_key, *translated_value;
+ GError *key_file_error;
+ gchar **languages;
+ gboolean free_languages = FALSE;
+ gint i;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ candidate_key = NULL;
+ translated_value = NULL;
+ key_file_error = NULL;
+
+ if (locale)
+ {
+ GSList *l, *list;
+
+ list = _g_compute_locale_variants (locale);
+
+ languages = g_new0 (gchar *, g_slist_length (list) + 1);
+ for (l = list, i = 0; l; l = l->next, i++)
+ languages[i] = l->data;
+ languages[i] = NULL;
+
+ g_slist_free (list);
+ free_languages = TRUE;
+ }
+ else
+ {
+ languages = (gchar **) g_get_language_names ();
+ free_languages = FALSE;
+ }
+
+ for (i = 0; languages[i]; i++)
+ {
+ candidate_key = g_strdup_printf ("%s[%s]", key, languages[i]);
+
+ translated_value = g_key_file_get_string (key_file,
+ group_name,
+ candidate_key, NULL);
+ g_free (candidate_key);
+
+ if (translated_value && g_utf8_validate (translated_value, -1, NULL))
+ break;
+
+ g_free (translated_value);
+ translated_value = NULL;
+ }
+
+ /* Fallback to untranslated key
+ */
+ if (!translated_value)
+ {
+ translated_value = g_key_file_get_string (key_file, group_name, key,
+ &key_file_error);
+
+ if (!translated_value)
+ g_propagate_error (error, key_file_error);
+ }
+
+ if (free_languages)
+ g_strfreev (languages);
+
+ return translated_value;
+}
+
+/**
+ * g_key_file_get_locale_string_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @locale: a locale
+ * @length: return location for the number of returned strings or %NULL
+ * @error: return location for a #GError or %NULL
+ *
+ * Returns the values associated with @key under @group_name
+ * translated in the given @locale if available. If @locale is
+ * %NULL then the current locale is assumed.
+
+ * If @key cannot be found then %NULL is returned and @error is set to
+ * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
+ * with @key cannot be interpreted or no suitable translations
+ * can be found then the untranslated values are returned.
+ * The returned array is %NULL-terminated, so @length may optionally be %NULL.
+ *
+ * Return value: a newly allocated %NULL-terminated string array
+ * or %NULL if the key isn't found. The string array should be freed
+ * with g_strfreev().
+ *
+ * Since: 2.6
+ **/
+gchar **
+g_key_file_get_locale_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ gsize *length,
+ GError **error)
+{
+ GError *key_file_error;
+ gchar **values, *value;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ key_file_error = NULL;
+
+ value = g_key_file_get_locale_string (key_file, group_name,
+ key, locale,
+ &key_file_error);
+
+ if (key_file_error)
+ g_propagate_error (error, key_file_error);
+
+ if (!value)
+ return NULL;
+
+ if (value[strlen (value) - 1] == ';')
+ value[strlen (value) - 1] = '\0';
+
+ values = g_strsplit (value, ";", 0);
+
+ g_free (value);
+
+ if (length)
+ *length = g_strv_length (values);
+
+ return values;
+}
+
+/**
+ * g_key_file_set_locale_string_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @locale: a locale
+ * @list: a %NULL-terminated array of locale string values
+ * @length: the length of @list
+ *
+ * Associates a list of string values for @key and @locale under
+ * @group_name. If the translation for @key cannot be found then
+ * it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_locale_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ const gchar * const list[],
+ gsize length)
+{
+ GString *value_list;
+ gchar *full_key;
+ gsize i;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (locale != NULL);
+ g_return_if_fail (length != 0);
+
+ value_list = g_string_sized_new (length * 128);
+ for (i = 0; list[i] != NULL && i < length; i++)
+ {
+ gchar *value;
+
+ value = g_key_file_parse_string_as_value (key_file, list[i], TRUE);
+
+ g_string_append (value_list, value);
+ g_string_append_c (value_list, ';');
+
+ g_free (value);
+ }
+
+ full_key = g_strdup_printf ("%s[%s]", key, locale);
+ g_key_file_set_value (key_file, group_name, full_key, value_list->str);
+ g_free (full_key);
+ g_string_free (value_list, TRUE);
+}
+
+/**
+ * g_key_file_get_boolean:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @error: return location for a #GError
+ *
+ * Returns the value associated with @key under @group_name as a
+ * boolean.
+ *
+ * If @key cannot be found then the return value is undefined and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if
+ * the value associated with @key cannot be interpreted as a boolean
+ * then the return value is also undefined and @error is set to
+ * #G_KEY_FILE_ERROR_INVALID_VALUE.
+ *
+ * Return value: the value associated with the key as a boolean
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_get_boolean (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gchar *value;
+ gboolean bool_value;
+
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (group_name != NULL, FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+
+ value = g_key_file_get_value (key_file, group_name, key, &key_file_error);
+
+ if (!value)
+ {
+ g_propagate_error (error, key_file_error);
+ return FALSE;
+ }
+
+ bool_value = g_key_file_parse_value_as_boolean (key_file, value,
+ &key_file_error);
+ g_free (value);
+
+ if (key_file_error)
+ {
+ if (g_error_matches (key_file_error,
+ G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains key '%s' "
+ "which has value that cannot be interpreted."),
+ key);
+ g_error_free (key_file_error);
+ }
+ else
+ g_propagate_error (error, key_file_error);
+ }
+
+ return bool_value;
+}
+
+/**
+ * g_key_file_set_boolean:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @value: %TRUE or %FALSE
+ *
+ * Associates a new boolean value with @key under @group_name.
+ * If @key cannot be found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_boolean (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gboolean value)
+{
+ gchar *result;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+
+ result = g_key_file_parse_boolean_as_value (key_file, value);
+ g_key_file_set_value (key_file, group_name, key, result);
+ g_free (result);
+}
+
+/**
+ * g_key_file_get_boolean_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @length: the number of booleans returned
+ * @error: return location for a #GError
+ *
+ * Returns the values associated with @key under @group_name as
+ * booleans. If @group_name is %NULL, the start_group is used.
+ *
+ * If @key cannot be found then the return value is undefined and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if
+ * the values associated with @key cannot be interpreted as booleans
+ * then the return value is also undefined and @error is set to
+ * #G_KEY_FILE_ERROR_INVALID_VALUE.
+ *
+ * Return value: the values associated with the key as a boolean
+ *
+ * Since: 2.6
+ **/
+gboolean *
+g_key_file_get_boolean_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error)
+{
+ GError *key_file_error;
+ gchar **values;
+ gboolean *bool_values;
+ gsize i, num_bools;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ key_file_error = NULL;
+
+ values = g_key_file_get_string_list (key_file, group_name, key,
+ &num_bools, &key_file_error);
+
+ if (key_file_error)
+ g_propagate_error (error, key_file_error);
+
+ if (!values)
+ return NULL;
+
+ bool_values = g_new0 (gboolean, num_bools);
+
+ for (i = 0; i < num_bools; i++)
+ {
+ bool_values[i] = g_key_file_parse_value_as_boolean (key_file,
+ values[i],
+ &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ g_strfreev (values);
+ g_free (bool_values);
+
+ return NULL;
+ }
+ }
+ g_strfreev (values);
+
+ if (length)
+ *length = num_bools;
+
+ return bool_values;
+}
+
+/**
+ * g_key_file_set_boolean_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @list: an array of boolean values
+ * @length: length of @list
+ *
+ * Associates a list of boolean values with @key under
+ * @group_name. If @key cannot be found then it is created.
+ * If @group_name is %NULL, the start_group is used.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_boolean_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gboolean list[],
+ gsize length)
+{
+ GString *value_list;
+ gsize i;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (list != NULL);
+
+ value_list = g_string_sized_new (length * 8);
+ for (i = 0; i < length; i++)
+ {
+ gchar *value;
+
+ value = g_key_file_parse_boolean_as_value (key_file, list[i]);
+
+ g_string_append (value_list, value);
+ g_string_append_c (value_list, key_file->list_separator);
+
+ g_free (value);
+ }
+
+ g_key_file_set_value (key_file, group_name, key, value_list->str);
+ g_string_free (value_list, TRUE);
+}
+
+/**
+ * g_key_file_get_integer:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @error: return location for a #GError
+ *
+ * Returns the value associated with @key under @group_name as an
+ * integer. If @group_name is %NULL, the start_group is used.
+ *
+ * If @key cannot be found then the return value is undefined and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if
+ * the value associated with @key cannot be interpreted as an integer
+ * then the return value is also undefined and @error is set to
+ * #G_KEY_FILE_ERROR_INVALID_VALUE.
+ *
+ * Return value: the value associated with the key as an integer.
+ *
+ * Since: 2.6
+ **/
+gint
+g_key_file_get_integer (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GError *key_file_error;
+ gchar *value;
+ gint int_value;
+
+ g_return_val_if_fail (key_file != NULL, -1);
+ g_return_val_if_fail (group_name != NULL, -1);
+ g_return_val_if_fail (key != NULL, -1);
+
+ key_file_error = NULL;
+
+ value = g_key_file_get_value (key_file, group_name, key, &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ return 0;
+ }
+
+ int_value = g_key_file_parse_value_as_integer (key_file, value,
+ &key_file_error);
+ g_free (value);
+
+ if (key_file_error)
+ {
+ if (g_error_matches (key_file_error,
+ G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE))
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains key '%s' in group '%s' "
+ "which has value that cannot be interpreted."), key,
+ group_name);
+ g_error_free (key_file_error);
+ }
+ else
+ g_propagate_error (error, key_file_error);
+ }
+
+ return int_value;
+}
+
+/**
+ * g_key_file_set_integer:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @value: an integer value
+ *
+ * Associates a new integer value with @key under @group_name.
+ * If @key cannot be found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_integer (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gint value)
+{
+ gchar *result;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+
+ result = g_key_file_parse_integer_as_value (key_file, value);
+ g_key_file_set_value (key_file, group_name, key, result);
+ g_free (result);
+}
+
+/**
+ * g_key_file_get_integer_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @length: the number of integers returned
+ * @error: return location for a #GError
+ *
+ * Returns the values associated with @key under @group_name as
+ * integers. If @group_name is %NULL, the start group is used.
+ *
+ * If @key cannot be found then the return value is undefined and
+ * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if
+ * the values associated with @key cannot be interpreted as integers
+ * then the return value is also undefined and @error is set to
+ * #G_KEY_FILE_ERROR_INVALID_VALUE.
+ *
+ * Return value: the values associated with the key as a integer
+ *
+ * Since: 2.6
+ **/
+gint *
+g_key_file_get_integer_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error)
+{
+ GError *key_file_error = NULL;
+ gchar **values;
+ gint *int_values;
+ gsize i, num_ints;
+
+ g_return_val_if_fail (key_file != NULL, NULL);
+ g_return_val_if_fail (group_name != NULL, NULL);
+ g_return_val_if_fail (key != NULL, NULL);
+
+ values = g_key_file_get_string_list (key_file, group_name, key,
+ &num_ints, &key_file_error);
+
+ if (key_file_error)
+ g_propagate_error (error, key_file_error);
+
+ if (!values)
+ return NULL;
+
+ int_values = g_new0 (gint, num_ints);
+
+ for (i = 0; i < num_ints; i++)
+ {
+ int_values[i] = g_key_file_parse_value_as_integer (key_file,
+ values[i],
+ &key_file_error);
+
+ if (key_file_error)
+ {
+ g_propagate_error (error, key_file_error);
+ g_strfreev (values);
+ g_free (int_values);
+
+ return NULL;
+ }
+ }
+ g_strfreev (values);
+
+ if (length)
+ *length = num_ints;
+
+ return int_values;
+}
+
+/**
+ * g_key_file_set_integer_list:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key
+ * @list: an array of integer values
+ * @length: number of integer values in @list
+ *
+ * Associates a list of integer values with @key under
+ * @group_name. If @key cannot be found then it is created.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_integer_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gint list[],
+ gsize length)
+{
+ GString *values;
+ gsize i;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+ g_return_if_fail (list != NULL);
+
+ values = g_string_sized_new (length * 16);
+ for (i = 0; i < length; i++)
+ {
+ gchar *value;
+
+ value = g_key_file_parse_integer_as_value (key_file, list[i]);
+
+ g_string_append (values, value);
+ g_string_append_c (values, ';');
+
+ g_free (value);
+ }
+
+ g_key_file_set_value (key_file, group_name, key, values->str);
+ g_string_free (values, TRUE);
+}
+
+static void
+g_key_file_set_key_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *comment,
+ GError **error)
+{
+ GKeyFileGroup *group;
+ GKeyFileKeyValuePair *pair;
+ GList *key_node, *comment_node, *tmp;
+
+ group = g_key_file_lookup_group (key_file, group_name);
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+
+ return;
+ }
+
+ /* First find the key the comments are supposed to be
+ * associated with
+ */
+ key_node = g_key_file_lookup_key_value_pair_node (key_file, group, key);
+
+ if (key_node == NULL)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_KEY_NOT_FOUND,
+ _("Key file does not have key '%s' in group '%s'"),
+ key, group->name);
+ return;
+ }
+
+ /* Then find all the comments already associated with the
+ * key and free them
+ */
+ tmp = key_node->next;
+ while (tmp != NULL)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) tmp->data;
+
+ if (pair->key != NULL)
+ break;
+
+ comment_node = tmp;
+ tmp = tmp->next;
+ g_key_file_remove_key_value_pair_node (key_file, group,
+ comment_node);
+ }
+
+ if (comment == NULL)
+ return;
+
+ /* Now we can add our new comment
+ */
+ pair = g_new0 (GKeyFileKeyValuePair, 1);
+
+ pair->key = NULL;
+ pair->value = g_key_file_parse_comment_as_value (key_file, comment);
+
+ key_node = g_list_insert (key_node, pair, 1);
+}
+
+static void
+g_key_file_set_group_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *comment,
+ GError **error)
+{
+ GKeyFileGroup *group;
+
+ group = g_key_file_lookup_group (key_file, group_name);
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+
+ return;
+ }
+
+ /* First remove any existing comment
+ */
+ if (group->comment)
+ {
+ g_key_file_key_value_pair_free (group->comment);
+ group->comment = NULL;
+ }
+
+ if (comment == NULL)
+ return;
+
+ /* Now we can add our new comment
+ */
+ group->comment = g_new0 (GKeyFileKeyValuePair, 1);
+
+ group->comment->key = NULL;
+ group->comment->value = g_key_file_parse_comment_as_value (key_file, comment);
+}
+
+static void
+g_key_file_set_top_comment (GKeyFile *key_file,
+ const gchar *comment,
+ GError **error)
+{
+ GList *group_node;
+ GKeyFileGroup *group;
+ GKeyFileKeyValuePair *pair;
+
+ /* The last group in the list should be the top (comments only)
+ * group in the file
+ */
+ g_assert (key_file->groups != NULL);
+ group_node = g_list_last (key_file->groups);
+ group = (GKeyFileGroup *) group_node->data;
+ g_assert (group->name == NULL);
+
+ /* Note all keys must be comments at the top of
+ * the file, so we can just free it all.
+ */
+ if (group->key_value_pairs != NULL)
+ {
+ g_list_foreach (group->key_value_pairs,
+ (GFunc) g_key_file_key_value_pair_free,
+ NULL);
+ g_list_free (group->key_value_pairs);
+ group->key_value_pairs = NULL;
+ }
+
+ if (comment == NULL)
+ return;
+
+ pair = g_new0 (GKeyFileKeyValuePair, 1);
+
+ pair->key = NULL;
+ pair->value = g_key_file_parse_comment_as_value (key_file, comment);
+
+ group->key_value_pairs =
+ g_list_prepend (group->key_value_pairs, pair);
+}
+
+/**
+ * g_key_file_set_comment:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name, or %NULL
+ * @key: a key
+ * @comment: a comment
+ * @error: return location for a #GError
+ *
+ * Places a comment above @key from @group_name.
+ * @group_name. If @key is %NULL then @comment will
+ * be written above @group_name. If both @key
+ * and @group_name are NULL, then @comment will
+ * be written above the first group in the file.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_set_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *comment,
+ GError **error)
+{
+ g_return_if_fail (key_file != NULL);
+
+ if (group_name != NULL && key != NULL)
+ g_key_file_set_key_comment (key_file, group_name, key, comment, error);
+ else if (group_name != NULL)
+ g_key_file_set_group_comment (key_file, group_name, comment, error);
+ else
+ g_key_file_set_top_comment (key_file, comment, error);
+
+ if (comment != NULL)
+ key_file->approximate_size += strlen (comment);
+}
+
+static gchar *
+g_key_file_get_key_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GKeyFileGroup *group;
+ GList *key_node, *tmp;
+ GString *string;
+ gchar *comment;
+
+ group = g_key_file_lookup_group (key_file, group_name);
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+
+ return NULL;
+ }
+
+ /* First find the key the comments are supposed to be
+ * associated with
+ */
+ key_node = g_key_file_lookup_key_value_pair_node (key_file, group, key);
+
+ if (key_node == NULL)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_KEY_NOT_FOUND,
+ _("Key file does not have key '%s' in group '%s'"),
+ key, group->name);
+ return NULL;
+ }
+
+ string = NULL;
+
+ /* Then find all the comments already associated with the
+ * key and concatentate them.
+ */
+ tmp = key_node->next;
+ while (tmp != NULL)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) tmp->data;
+
+ if (pair->key != NULL)
+ break;
+
+ if (string == NULL)
+ string = g_string_sized_new (512);
+
+ comment = g_key_file_parse_value_as_comment (key_file, pair->value);
+ g_string_append (string, comment);
+ g_free (comment);
+
+ tmp = tmp->next;
+ }
+
+ if (string != NULL)
+ {
+ comment = string->str;
+ g_string_free (string, FALSE);
+ }
+ else
+ comment = NULL;
+
+ return comment;
+}
+
+static gchar *
+g_key_file_get_group_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ GError **error)
+{
+ GKeyFileGroup *group;
+
+ group = g_key_file_lookup_group (key_file, group_name);
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+
+ return NULL;
+ }
+
+ if (group->comment)
+ return g_strdup (group->comment->value);
+
+ return NULL;
+}
+
+static gchar *
+g_key_file_get_top_comment (GKeyFile *key_file,
+ GError **error)
+{
+ GList *group_node, *tmp;
+ GKeyFileGroup *group;
+ GString *string;
+ gchar *comment;
+
+ /* The last group in the list should be the top (comments only)
+ * group in the file
+ */
+ g_assert (key_file->groups != NULL);
+ group_node = g_list_last (key_file->groups);
+ group = (GKeyFileGroup *) group_node->data;
+ g_assert (group->name == NULL);
+
+ string = NULL;
+
+ /* Then find all the comments already associated with the
+ * key and concatentate them.
+ */
+ tmp = group->key_value_pairs;
+ while (tmp != NULL)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) tmp->data;
+
+ if (pair->key != NULL)
+ break;
+
+ if (string == NULL)
+ string = g_string_sized_new (512);
+
+ comment = g_key_file_parse_value_as_comment (key_file, pair->value);
+ g_string_append (string, comment);
+ g_free (comment);
+
+ tmp = tmp->next;
+ }
+
+ if (string != NULL)
+ {
+ comment = string->str;
+ g_string_free (string, FALSE);
+ }
+ else
+ comment = NULL;
+
+ return comment;
+}
+
+/**
+ * g_key_file_get_comment:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name, or %NULL
+ * @key: a key
+ * @error: return location for a #GError
+ *
+ * Retreives a comment above @key from @group_name.
+ * @group_name. If @key is %NULL then @comment will
+ * be read from above @group_name. If both @key
+ * and @group_name are NULL, then @comment will
+ * be read from above the first group in the file.
+ *
+ * Since: 2.6
+ * Returns: a comment that should be freed with g_free()
+ **/
+gchar *
+g_key_file_get_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ g_return_val_if_fail (key_file != NULL, NULL);
+
+ if (group_name != NULL && key != NULL)
+ return g_key_file_get_key_comment (key_file, group_name, key, error);
+ else if (group_name != NULL)
+ return g_key_file_get_group_comment (key_file, group_name, error);
+ else
+ return g_key_file_get_top_comment (key_file, error);
+}
+
+/**
+ * g_key_file_remove_comment:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name, or %NULL
+ * @key: a key
+ * @error: return location for a #GError
+ *
+ * Removes a comment above @key from @group_name.
+ * @group_name. If @key is %NULL then @comment will
+ * be written above @group_name. If both @key
+ * and @group_name are NULL, then @comment will
+ * be written above the first group in the file.
+ *
+ * Since: 2.6
+ **/
+
+void
+g_key_file_remove_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ g_return_if_fail (key_file != NULL);
+
+ if (group_name != NULL && key != NULL)
+ g_key_file_set_key_comment (key_file, group_name, key, NULL, error);
+ else if (group_name != NULL)
+ g_key_file_set_group_comment (key_file, group_name, NULL, error);
+ else
+ g_key_file_set_top_comment (key_file, NULL, error);
+}
+
+/**
+ * g_key_file_has_group:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ *
+ * Looks whether the key file has the group @group_name.
+ *
+ * Return value: %TRUE if @group_name is a part of @key_file, %FALSE
+ * otherwise.
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_has_group (GKeyFile *key_file,
+ const gchar *group_name)
+{
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (group_name != NULL, FALSE);
+
+ return g_key_file_lookup_group_node (key_file, group_name) != NULL;
+}
+
+/**
+ * g_key_file_has_key:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key name
+ * @error: return location for a #GError
+ *
+ * Looks whether the key file has the key @key in the group
+ * @group_name.
+ *
+ * Return value: %TRUE if @key is a part of @group_name, %FALSE
+ * otherwise.
+ *
+ * Since: 2.6
+ **/
+gboolean
+g_key_file_has_key (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GKeyFileKeyValuePair *pair;
+ GKeyFileGroup *group;
+
+ g_return_val_if_fail (key_file != NULL, FALSE);
+ g_return_val_if_fail (group_name != NULL, FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+
+ group = g_key_file_lookup_group (key_file, group_name);
+
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+
+ return FALSE;
+ }
+
+ pair = g_key_file_lookup_key_value_pair (key_file, group, key);
+
+ return pair != NULL;
+}
+
+static void
+g_key_file_add_group (GKeyFile *key_file,
+ const gchar *group_name)
+{
+ GKeyFileGroup *group;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (g_key_file_lookup_group_node (key_file, group_name) == NULL);
+
+ group = g_new0 (GKeyFileGroup, 1);
+ group->name = g_strdup (group_name);
+ group->lookup_map = g_hash_table_new (g_str_hash, g_str_equal);
+ key_file->groups = g_list_prepend (key_file->groups, group);
+ key_file->approximate_size += strlen (group_name) + 3;
+ key_file->current_group = group;
+
+ if (key_file->start_group == NULL)
+ key_file->start_group = group;
+}
+
+static void
+g_key_file_key_value_pair_free (GKeyFileKeyValuePair *pair)
+{
+ if (pair != NULL)
+ {
+ g_free (pair->key);
+ g_free (pair->value);
+ g_free (pair);
+ }
+}
+
+/* Be careful not to call this function on a node with data in the
+ * lookup map without removing it from the lookup map, first.
+ *
+ * Some current cases where this warning is not a concern are
+ * when:
+ * - the node being removed is a comment node
+ * - the entire lookup map is getting destroyed soon after
+ * anyway.
+ */
+static void
+g_key_file_remove_key_value_pair_node (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ GList *pair_node)
+{
+
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) pair_node->data;
+
+ group->key_value_pairs = g_list_remove_link (group->key_value_pairs, pair_node);
+
+ if (pair->key != NULL)
+ key_file->approximate_size -= strlen (pair->key) + 1;
+
+ g_assert (pair->value != NULL);
+ key_file->approximate_size -= strlen (pair->value);
+
+ g_key_file_key_value_pair_free (pair);
+
+ g_list_free_1 (pair_node);
+}
+
+static void
+g_key_file_remove_group_node (GKeyFile *key_file,
+ GList *group_node)
+{
+ GKeyFileGroup *group;
+ GList *tmp;
+
+ group = (GKeyFileGroup *) group_node->data;
+
+ /* If the current group gets deleted make the current group the last
+ * added group.
+ */
+ if (key_file->current_group == group)
+ {
+ /* groups should always contain at least the top comment group,
+ * unless g_key_file_clear has been called
+ */
+ if (key_file->groups)
+ key_file->current_group = (GKeyFileGroup *) key_file->groups->data;
+ else
+ key_file->current_group = NULL;
+ }
+
+ /* If the start group gets deleted make the start group the first
+ * added group.
+ */
+ if (key_file->start_group == group)
+ {
+ tmp = g_list_last (key_file->groups);
+ while (tmp != NULL)
+ {
+ if (tmp != group_node &&
+ ((GKeyFileGroup *) tmp->data)->name != NULL)
+ break;
+
+ tmp = tmp->prev;
+ }
+
+ if (tmp)
+ key_file->start_group = (GKeyFileGroup *) tmp->data;
+ else
+ key_file->start_group = NULL;
+ }
+
+ key_file->groups = g_list_remove_link (key_file->groups, group_node);
+
+ if (group->name != NULL)
+ key_file->approximate_size -= strlen (group->name) + 3;
+
+ tmp = group->key_value_pairs;
+ while (tmp != NULL)
+ {
+ GList *pair_node;
+
+ pair_node = tmp;
+ tmp = tmp->next;
+ g_key_file_remove_key_value_pair_node (key_file, group, pair_node);
+ }
+
+ g_assert (group->key_value_pairs == NULL);
+
+ if (group->lookup_map)
+ {
+ g_hash_table_destroy (group->lookup_map);
+ group->lookup_map = NULL;
+ }
+
+ g_free ((gchar *) group->name);
+ g_free (group);
+ g_list_free_1 (group_node);
+}
+
+/**
+ * g_key_file_remove_group:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @error: return location for a #GError or %NULL
+ *
+ * Removes the specified group, @group_name,
+ * from the key file.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_remove_group (GKeyFile *key_file,
+ const gchar *group_name,
+ GError **error)
+{
+ GList *group_node;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+
+ group_node = g_key_file_lookup_group_node (key_file, group_name);
+
+ if (!group_node)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name);
+ return;
+ }
+
+ g_key_file_remove_group_node (key_file, group_node);
+}
+
+static void
+g_key_file_add_key (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key,
+ const gchar *value)
+{
+ GKeyFileKeyValuePair *pair;
+
+ pair = g_new0 (GKeyFileKeyValuePair, 1);
+
+ pair->key = g_strdup (key);
+ pair->value = g_strdup (value);
+
+ g_hash_table_replace (group->lookup_map, pair->key, pair);
+ group->key_value_pairs = g_list_prepend (group->key_value_pairs, pair);
+ key_file->approximate_size += strlen (key) + strlen (value) + 2;
+}
+
+/**
+ * g_key_file_remove_key:
+ * @key_file: a #GKeyFile
+ * @group_name: a group name
+ * @key: a key name to remove
+ * @error: return location for a #GError or %NULL
+ *
+ * Removes @key in @group_name from the key file.
+ *
+ * Since: 2.6
+ **/
+void
+g_key_file_remove_key (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error)
+{
+ GKeyFileGroup *group;
+ GKeyFileKeyValuePair *pair;
+
+ g_return_if_fail (key_file != NULL);
+ g_return_if_fail (group_name != NULL);
+ g_return_if_fail (key != NULL);
+
+ pair = NULL;
+
+ group = g_key_file_lookup_group (key_file, group_name);
+ if (!group)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ _("Key file does not have group '%s'"),
+ group_name ? group_name : "(null)");
+ return;
+ }
+
+ pair = g_key_file_lookup_key_value_pair (key_file, group, key);
+
+ if (!pair)
+ {
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_KEY_NOT_FOUND,
+ _("Key file does not have key '%s' in group '%s'"),
+ key, group->name);
+ return;
+ }
+
+ key_file->approximate_size -= strlen (pair->key) + strlen (pair->value) + 2;
+
+ group->key_value_pairs = g_list_remove (group->key_value_pairs, pair);
+ g_hash_table_remove (group->lookup_map, pair->key);
+ g_key_file_key_value_pair_free (pair);
+}
+
+static GList *
+g_key_file_lookup_group_node (GKeyFile *key_file,
+ const gchar *group_name)
+{
+ GKeyFileGroup *group;
+ GList *tmp;
+
+ group = NULL;
+ for (tmp = key_file->groups; tmp != NULL; tmp = tmp->next)
+ {
+ group = (GKeyFileGroup *) tmp->data;
+
+ if (group && group->name && strcmp (group->name, group_name) == 0)
+ break;
+
+ group = NULL;
+ }
+
+ return tmp;
+}
+
+static GKeyFileGroup *
+g_key_file_lookup_group (GKeyFile *key_file,
+ const gchar *group_name)
+{
+ GList *group_node;
+
+ group_node = g_key_file_lookup_group_node (key_file, group_name);
+
+ if (group_node != NULL)
+ return (GKeyFileGroup *) group_node->data;
+
+ return NULL;
+}
+
+static GList *
+g_key_file_lookup_key_value_pair_node (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key)
+{
+ GList *key_node;
+
+ for (key_node = group->key_value_pairs;
+ key_node != NULL;
+ key_node = key_node->next)
+ {
+ GKeyFileKeyValuePair *pair;
+
+ pair = (GKeyFileKeyValuePair *) key_node->data;
+
+ if (pair->key && strcmp (pair->key, key) == 0)
+ break;
+ }
+
+ return key_node;
+}
+
+static GKeyFileKeyValuePair *
+g_key_file_lookup_key_value_pair (GKeyFile *key_file,
+ GKeyFileGroup *group,
+ const gchar *key)
+{
+ return (GKeyFileKeyValuePair *) g_hash_table_lookup (group->lookup_map, key);
+}
+
+/* Lines starting with # or consisting entirely of whitespace are merely
+ * recorded, not parsed. This function assumes all leading whitespace
+ * has been stripped.
+ */
+static gboolean
+g_key_file_line_is_comment (const gchar *line)
+{
+ return (*line == '#' || *line == '\0' || *line == '\n');
+}
+
+/* A group in a key file is made up of a starting '[' followed by one
+ * or more letters making up the group name followed by ']'.
+ */
+static gboolean
+g_key_file_line_is_group (const gchar *line)
+{
+ gchar *p;
+
+ p = (gchar *) line;
+ if (*p != '[')
+ return FALSE;
+
+ p = g_utf8_next_char (p);
+
+ if (!*p)
+ return FALSE;
+
+ p = g_utf8_next_char (p);
+
+ /* Group name must be non-empty
+ */
+ if (*p == ']')
+ return FALSE;
+
+ while (*p && *p != ']')
+ p = g_utf8_next_char (p);
+
+ if (!*p)
+ return FALSE;
+
+ return TRUE;
+}
+
+static gboolean
+g_key_file_line_is_key_value_pair (const gchar *line)
+{
+ gchar *p;
+
+ p = (gchar *) g_utf8_strchr (line, -1, '=');
+
+ if (!p)
+ return FALSE;
+
+ /* Key must be non-empty
+ */
+ if (*p == line[0])
+ return FALSE;
+
+ return TRUE;
+}
+
+static gchar *
+g_key_file_parse_value_as_string (GKeyFile *key_file,
+ const gchar *value,
+ GSList **pieces,
+ GError **error)
+{
+ gchar *string_value, *p, *q0, *q;
+
+ string_value = g_new0 (gchar, strlen (value) + 1);
+
+ p = (gchar *) value;
+ q0 = q = string_value;
+ while (*p)
+ {
+ if (*p == '\\')
+ {
+ p++;
+
+ switch (*p)
+ {
+ case 's':
+ *q = ' ';
+ break;
+
+ case 'n':
+ *q = '\n';
+ break;
+
+ case 't':
+ *q = '\t';
+ break;
+
+ case 'r':
+ *q = '\r';
+ break;
+
+ case '\\':
+ *q = '\\';
+ break;
+
+ case '\0':
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains escape character "
+ "at end of line"));
+ break;
+
+ default:
+ if (pieces && *p == key_file->list_separator)
+ *q = key_file->list_separator;
+ else
+ {
+ *q++ = '\\';
+ *q = *p;
+
+ if (*error == NULL)
+ {
+ gchar sequence[3];
+
+ sequence[0] = '\\';
+ sequence[1] = *p;
+ sequence[2] = '\0';
+
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Key file contains invalid escape "
+ "sequence '%s'"), sequence);
+ }
+ }
+ break;
+ }
+ }
+ else
+ {
+ *q = *p;
+ if (pieces && (*p == key_file->list_separator))
+ {
+ *pieces = g_slist_prepend (*pieces, g_strndup (q0, q - q0));
+ q0 = q + 1;
+ }
+ }
+
+ if (*p == '\0')
+ break;
+
+ q++;
+ p++;
+ }
+
+ *q = '\0';
+ if (pieces)
+ {
+ if (q0 < q)
+ *pieces = g_slist_prepend (*pieces, g_strndup (q0, q - q0));
+ *pieces = g_slist_reverse (*pieces);
+ }
+
+ return string_value;
+}
+
+static gchar *
+g_key_file_parse_string_as_value (GKeyFile *key_file,
+ const gchar *string,
+ gboolean escape_separator)
+{
+ gchar *value, *p, *q;
+ gsize length;
+ gboolean parsing_leading_space;
+
+ length = strlen (string) + 1;
+
+ /* Worst case would be that every character needs to be escaped.
+ * In other words every character turns to two characters
+ */
+ value = g_new0 (gchar, 2 * length);
+
+ p = (gchar *) string;
+ q = value;
+ parsing_leading_space = TRUE;
+ while (p < (string + length - 1))
+ {
+ gchar escaped_character[3] = { '\\', 0, 0 };
+
+ switch (*p)
+ {
+ case ' ':
+ if (parsing_leading_space)
+ {
+ escaped_character[1] = 's';
+ strcpy (q, escaped_character);
+ q += 2;
+ }
+ else
+ {
+ *q = *p;
+ q++;
+ }
+ break;
+ case '\t':
+ if (parsing_leading_space)
+ {
+ escaped_character[1] = 't';
+ strcpy (q, escaped_character);
+ q += 2;
+ }
+ else
+ {
+ *q = *p;
+ q++;
+ }
+ break;
+ case '\n':
+ escaped_character[1] = 'n';
+ strcpy (q, escaped_character);
+ q += 2;
+ break;
+ case '\r':
+ escaped_character[1] = 'r';
+ strcpy (q, escaped_character);
+ q += 2;
+ break;
+ case '\\':
+ escaped_character[1] = '\\';
+ strcpy (q, escaped_character);
+ q += 2;
+ parsing_leading_space = FALSE;
+ break;
+ default:
+ if (escape_separator && *p == key_file->list_separator)
+ {
+ escaped_character[1] = key_file->list_separator;
+ strcpy (q, escaped_character);
+ q += 2;
+ parsing_leading_space = TRUE;
+ }
+ else
+ {
+ *q = *p;
+ q++;
+ parsing_leading_space = FALSE;
+ }
+ break;
+ }
+ p++;
+ }
+ *q = '\0';
+
+ return value;
+}
+
+static gint
+g_key_file_parse_value_as_integer (GKeyFile *key_file,
+ const gchar *value,
+ GError **error)
+{
+ gchar *end_of_valid_int;
+ gint int_value = 0;
+
+ int_value = strtol (value, &end_of_valid_int, 10);
+
+ if (*end_of_valid_int != '\0')
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Value '%s' cannot be interpreted as a number."), value);
+
+ return int_value;
+}
+
+static gchar *
+g_key_file_parse_integer_as_value (GKeyFile *key_file,
+ gint value)
+
+{
+ return g_strdup_printf ("%d", value);
+}
+
+static gboolean
+g_key_file_parse_value_as_boolean (GKeyFile *key_file,
+ const gchar *value,
+ GError **error)
+{
+ if (value)
+ {
+ if (strcmp (value, "true") == 0 || strcmp (value, "1") == 0)
+ return TRUE;
+ else if (strcmp (value, "false") == 0 || strcmp (value, "0") == 0)
+ return FALSE;
+ }
+
+ g_set_error (error, G_KEY_FILE_ERROR,
+ G_KEY_FILE_ERROR_INVALID_VALUE,
+ _("Value '%s' cannot be interpreted as a boolean."), value);
+
+ return FALSE;
+}
+
+static gchar *
+g_key_file_parse_boolean_as_value (GKeyFile *key_file,
+ gboolean value)
+{
+ if (value)
+ return g_strdup ("true");
+ else
+ return g_strdup ("false");
+}
+
+static gchar *
+g_key_file_parse_value_as_comment (GKeyFile *key_file,
+ const gchar *value)
+{
+ GString *string;
+ gchar **lines, *comment;
+ gsize i;
+
+ string = g_string_sized_new (512);
+
+ lines = g_strsplit (value, "\n", 0);
+
+ for (i = 0; lines[i] != NULL; i++)
+ {
+ if (lines[i][0] != '#')
+ g_string_append_printf (string, "%s\n", lines[i]);
+ else
+ g_string_append_printf (string, "%s\n", lines[i] + 1);
+ }
+ g_strfreev (lines);
+
+ comment = string->str;
+
+ g_string_free (string, FALSE);
+
+ return comment;
+}
+
+static gchar *
+g_key_file_parse_comment_as_value (GKeyFile *key_file,
+ const gchar *comment)
+{
+ GString *string;
+ gchar **lines, *value;
+ gsize i;
+
+ string = g_string_sized_new (512);
+
+ lines = g_strsplit (comment, "\n", 0);
+
+ for (i = 0; lines[i] != NULL; i++)
+ g_string_append_printf (string, "#%s%s", lines[i],
+ lines[i + 1] == NULL? "" : "\n");
+ g_strfreev (lines);
+
+ value = string->str;
+
+ g_string_free (string, FALSE);
+
+ return value;
+}
+
+/* Start hacks to make this file compile with glib 2.4 */
+#if 0
+#define __G_KEY_FILE_C__
+#include "galiasdef.c"
+#endif
+/* End hacks to make this file compile with glib 2.4 */
--- /dev/null
+++ lib/glib26/Makefile.am
@@ -0,0 +1,11 @@
+noinst_LTLIBRARIES = libgncglib.la
+
+if HAVE_GLIB26
+libgncglib_la_SOURCES = dummy.c
+else
+libgncglib_la_SOURCES = gkeyfile.c gkeyfile.h gutils26.c gutils26.h
+endif
+
+libgncglib_la_LIBADD = ${GLIB_LIBS}
+
+AM_CFLAGS = ${GLIB_CFLAGS}
--- /dev/null
+++ lib/glib26/gkeyfile.h
@@ -0,0 +1,199 @@
+/* gkeyfile.h - desktop entry file parser
+ *
+ * Copyright 2004 Red Hat, Inc.
+ *
+ * Ray Strode <halfline at hawaii.rr.com>
+ *
+ * GLib is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * GLib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GLib; see the file COPYING.LIB. If not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_KEY_FILE_H__
+#define __G_KEY_FILE_H__
+
+#include <glib/gerror.h>
+
+/* Start hacks to make this file compile with glib 2.4 */
+#define G_GNUC_MALLOC
+/* End hacks to make this file compile with glib 2.4 */
+
+G_BEGIN_DECLS
+
+typedef enum
+{
+ G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
+ G_KEY_FILE_ERROR_PARSE,
+ G_KEY_FILE_ERROR_NOT_FOUND,
+ G_KEY_FILE_ERROR_KEY_NOT_FOUND,
+ G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
+ G_KEY_FILE_ERROR_INVALID_VALUE
+} GKeyFileError;
+
+#define G_KEY_FILE_ERROR g_key_file_error_quark()
+
+GQuark g_key_file_error_quark (void);
+
+typedef struct _GKeyFile GKeyFile;
+
+typedef enum
+{
+ G_KEY_FILE_NONE = 0,
+ G_KEY_FILE_KEEP_COMMENTS = 1 << 0,
+ G_KEY_FILE_KEEP_TRANSLATIONS = 1 << 1
+} GKeyFileFlags;
+
+GKeyFile *g_key_file_new (void);
+void g_key_file_free (GKeyFile *key_file);
+void g_key_file_set_list_separator (GKeyFile *key_file,
+ gchar separator);
+gboolean g_key_file_load_from_file (GKeyFile *key_file,
+ const gchar *file,
+ GKeyFileFlags flags,
+ GError **error);
+gboolean g_key_file_load_from_data (GKeyFile *key_file,
+ const gchar *data,
+ gsize length,
+ GKeyFileFlags flags,
+ GError **error);
+gboolean g_key_file_load_from_data_dirs (GKeyFile *key_file,
+ const gchar *file,
+ gchar **full_path,
+ GKeyFileFlags flags,
+ GError **error);
+gchar *g_key_file_to_data (GKeyFile *key_file,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+gchar *g_key_file_get_start_group (GKeyFile *key_file) G_GNUC_MALLOC;
+gchar **g_key_file_get_groups (GKeyFile *key_file,
+ gsize *length) G_GNUC_MALLOC;
+gchar **g_key_file_get_keys (GKeyFile *key_file,
+ const gchar *group_name,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+gboolean g_key_file_has_group (GKeyFile *key_file,
+ const gchar *group_name);
+gboolean g_key_file_has_key (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error);
+gchar *g_key_file_get_value (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_value (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *value);
+gchar *g_key_file_get_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *string);
+gchar *g_key_file_get_locale_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_locale_string (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ const gchar *string);
+gboolean g_key_file_get_boolean (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error);
+void g_key_file_set_boolean (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gboolean value);
+gint g_key_file_get_integer (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error);
+void g_key_file_set_integer (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gint value);
+gchar **g_key_file_get_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar * const list[],
+ gsize length);
+gchar **g_key_file_get_locale_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_locale_string_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *locale,
+ const gchar * const list[],
+ gsize length);
+gboolean *g_key_file_get_boolean_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_boolean_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gboolean list[],
+ gsize length);
+gint *g_key_file_get_integer_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+void g_key_file_set_integer_list (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ gint list[],
+ gsize length);
+void g_key_file_set_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ const gchar *comment,
+ GError **error);
+gchar *g_key_file_get_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error) G_GNUC_MALLOC;
+
+void g_key_file_remove_comment (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error);
+void g_key_file_remove_key (GKeyFile *key_file,
+ const gchar *group_name,
+ const gchar *key,
+ GError **error);
+void g_key_file_remove_group (GKeyFile *key_file,
+ const gchar *group_name,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __G_KEY_FILE_H__ */
--- /dev/null
+++ lib/glib26/gutils26.c
@@ -0,0 +1,1041 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1998 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GLib Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+/*
+ * MT safe for the unix part, FIXME: make the win32 part MT safe as well.
+ */
+
+#include "config.h"
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <locale.h>
+#include <string.h>
+#include <errno.h>
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#include <sys/types.h>
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+/* implement gutils's inline functions
+ */
+#define G_IMPLEMENT_INLINES 1
+#define __G_UTILS_C__
+/* Start hacks to make this file compile with glib 2.4 */
+#include <glib.h>
+#include "gutils26.h"
+/* End hacks to make this file compile with glib 2.4 */
+#if 0
+#include "glib.h"
+#include "gprintfint.h"
+#include "gthreadinit.h"
+#include "galias.h"
+#endif
+
+#ifdef G_PLATFORM_WIN32
+# define STRICT /* Strict typing, please */
+# include <windows.h>
+# undef STRICT
+# include <lmcons.h> /* For UNLEN */
+#endif /* G_PLATFORM_WIN32 */
+
+#ifdef G_OS_WIN32
+# include <direct.h>
+# include <shlobj.h>
+ /* older SDK (e.g. msvc 5.0) does not have these*/
+# ifndef CSIDL_INTERNET_CACHE
+# define CSIDL_INTERNET_CACHE 32
+# endif
+# ifndef CSIDL_COMMON_APPDATA
+# define CSIDL_COMMON_APPDATA 35
+# endif
+# ifndef CSIDL_COMMON_DOCUMENTS
+# define CSIDL_COMMON_DOCUMENTS 46
+# endif
+# ifndef CSIDL_PROFILE
+# define CSIDL_PROFILE 40
+# endif
+#endif
+
+#ifdef HAVE_CODESET
+#include <langinfo.h>
+#endif
+
+#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
+#include <libintl.h>
+#endif
+
+const guint glib_major_version = GLIB_MAJOR_VERSION;
+const guint glib_minor_version = GLIB_MINOR_VERSION;
+const guint glib_micro_version = GLIB_MICRO_VERSION;
+#if 0
+const guint glib_interface_age = GLIB_INTERFACE_AGE;
+const guint glib_binary_age = GLIB_BINARY_AGE;
+#endif
+
+/**
+ * glib_check_version:
+ * @required_major: the required major version.
+ * @required_minor: the required major version.
+ * @required_micro: the required major version.
+ *
+ * Checks that the GLib library in use is compatible with the
+ * given version. Generally you would pass in the constants
+ * #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION
+ * as the three arguments to this function; that produces
+ * a check that the library in use is compatible with
+ * the version of GLib the application or module was compiled
+ * against.
+ *
+ * Compatibility is defined by two things: first the version
+ * of the running library is newer than the version
+ * @required_major.required_minor. at required_micro. Second
+ * the running library must be binary compatible with the
+ * version @required_major.required_minor. at required_micro
+ * (same major version.)
+ *
+ * Return value: %NULL if the GLib library is compatible with the
+ * given version, or a string describing the version mismatch.
+ * The returned string is owned by GLib and must not be modified
+ * or freed.
+ *
+ * Since: 2.6
+ **/
+const gchar *
+glib_check_version (guint required_major,
+ guint required_minor,
+ guint required_micro)
+{
+ gint glib_effective_micro = 100 * GLIB_MINOR_VERSION + GLIB_MICRO_VERSION;
+ gint required_effective_micro = 100 * required_minor + required_micro;
+
+ if (required_major > GLIB_MAJOR_VERSION)
+ return "GLib version too old (major mismatch)";
+ if (required_major < GLIB_MAJOR_VERSION)
+ return "GLib version too new (major mismatch)";
+#if 0
+ if (required_effective_micro < glib_effective_micro - GLIB_BINARY_AGE)
+ return "GLib version too new (micro mismatch)";
+#endif
+ if (required_effective_micro > glib_effective_micro)
+ return "GLib version too old (micro mismatch)";
+ return NULL;
+}
+
+/* Based on execvp() from GNU Libc.
+ * Some of this code is cut-and-pasted into gspawn.c
+ */
+
+G_LOCK_DEFINE_STATIC (g_utils_global);
+
+static gchar *g_user_data_dir = NULL;
+static gchar **g_system_data_dirs = NULL;
+static gchar *g_user_cache_dir = NULL;
+static gchar *g_user_config_dir = NULL;
+static gchar **g_system_config_dirs = NULL;
+
+#ifdef G_OS_WIN32
+
+static gchar *
+get_special_folder (int csidl)
+{
+ union {
+ char c[MAX_PATH+1];
+ wchar_t wc[MAX_PATH+1];
+ } path;
+ HRESULT hr;
+ LPITEMIDLIST pidl = NULL;
+ BOOL b;
+ gchar *retval = NULL;
+
+ hr = SHGetSpecialFolderLocation (NULL, csidl, &pidl);
+ if (hr == S_OK)
+ {
+ if (G_WIN32_HAVE_WIDECHAR_API ())
+ {
+ b = SHGetPathFromIDListW (pidl, path.wc);
+ if (b)
+ retval = g_utf16_to_utf8 (path.wc, -1, NULL, NULL, NULL);
+ }
+ else
+ {
+ b = SHGetPathFromIDListA (pidl, path.c);
+ if (b)
+ retval = g_locale_to_utf8 (path.c, -1, NULL, NULL, NULL);
+ }
+ CoTaskMemFree (pidl);
+ }
+ return retval;
+}
+
+#endif
+
+G_LOCK_DEFINE_STATIC (g_prgname);
+static gchar *g_prgname = NULL;
+
+gchar*
+g_get_prgname (void)
+{
+ gchar* retval;
+
+ G_LOCK (g_prgname);
+#ifdef G_OS_WIN32
+ if (g_prgname == NULL)
+ {
+ static gboolean beenhere = FALSE;
+
+ if (!beenhere)
+ {
+ gchar *utf8_buf = NULL;
+
+ beenhere = TRUE;
+ if (G_WIN32_HAVE_WIDECHAR_API ())
+ {
+ wchar_t buf[MAX_PATH+1];
+ if (GetModuleFileNameW (GetModuleHandle (NULL),
+ buf, G_N_ELEMENTS (buf)) > 0)
+ utf8_buf = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
+ }
+ else
+ {
+ gchar buf[MAX_PATH+1];
+ if (GetModuleFileNameA (GetModuleHandle (NULL),
+ buf, G_N_ELEMENTS (buf)) > 0)
+ utf8_buf = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
+ }
+ if (utf8_buf)
+ {
+ g_prgname = g_path_get_basename (utf8_buf);
+ g_free (utf8_buf);
+ }
+ }
+ }
+#endif
+ retval = g_prgname;
+ G_UNLOCK (g_prgname);
+
+ return retval;
+}
+
+void
+g_set_prgname (const gchar *prgname)
+{
+ G_LOCK (g_prgname);
+ g_free (g_prgname);
+ g_prgname = g_strdup (prgname);
+ G_UNLOCK (g_prgname);
+}
+
+G_LOCK_DEFINE_STATIC (g_application_name);
+static gchar *g_application_name = NULL;
+
+/**
+ * g_get_application_name:
+ *
+ * Gets a human-readable name for the application, as set by
+ * g_set_application_name(). This name should be localized if
+ * possible, and is intended for display to the user. Contrast with
+ * g_get_prgname(), which gets a non-localized name. If
+ * g_set_application_name() has not been called, returns the result of
+ * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
+ * been called).
+ *
+ * Return value: human-readable application name. may return %NULL
+ *
+ * Since: 2.2
+ **/
+G_CONST_RETURN gchar*
+g_get_application_name (void)
+{
+ gchar* retval;
+
+ G_LOCK (g_application_name);
+ retval = g_application_name;
+ G_UNLOCK (g_application_name);
+
+ if (retval == NULL)
+ return g_get_prgname ();
+
+ return retval;
+}
+
+/**
+ * g_set_application_name:
+ * @application_name: localized name of the application
+ *
+ * Sets a human-readable name for the application. This name should be
+ * localized if possible, and is intended for display to the user.
+ * Contrast with g_set_prgname(), which sets a non-localized name.
+ * g_set_prgname() will be called automatically by gtk_init(),
+ * but g_set_application_name() will not.
+ *
+ * Note that for thread safety reasons, this function can only
+ * be called once.
+ *
+ * The application name will be used in contexts such as error messages,
+ * or when displaying an application's name in the task list.
+ *
+ **/
+void
+g_set_application_name (const gchar *application_name)
+{
+ gboolean already_set = FALSE;
+
+ G_LOCK (g_application_name);
+ if (g_application_name)
+ already_set = TRUE;
+ else
+ g_application_name = g_strdup (application_name);
+ G_UNLOCK (g_application_name);
+
+ if (already_set)
+ g_warning ("g_set_application() name called multiple times");
+}
+
+/**
+ * g_get_user_data_dir:
+ *
+ * Returns a base directory in which to access application data such
+ * as icons that is customized for a particular user.
+ *
+ * On Unix platforms this is determined using the mechanisms described in
+ * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
+ * XDG Base Directory Specification</ulink>
+ *
+ * Return value: a string owned by GLib that must not be modified
+ * or freed.
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar*
+g_get_user_data_dir (void)
+{
+ gchar *data_dir;
+
+ G_LOCK (g_utils_global);
+
+ if (!g_user_data_dir)
+ {
+#ifdef G_OS_WIN32
+ data_dir = get_special_folder (CSIDL_PERSONAL);
+#else
+ data_dir = (gchar *) g_getenv ("XDG_DATA_HOME");
+
+ if (data_dir && data_dir[0])
+ data_dir = g_strdup (data_dir);
+#endif
+ if (!data_dir || !data_dir[0])
+ {
+ if (g_get_home_dir())
+ data_dir = g_build_filename (g_get_home_dir(), ".local",
+ "share", NULL);
+ else
+ data_dir = g_build_filename (g_get_tmp_dir(), g_get_user_name(), ".local",
+ "share", NULL);
+ }
+
+ g_user_data_dir = data_dir;
+ }
+ else
+ data_dir = g_user_data_dir;
+
+ G_UNLOCK (g_utils_global);
+
+ return data_dir;
+}
+
+/**
+ * g_get_user_config_dir:
+ *
+ * Returns a base directory in which to store user-specific application
+ * configuration information such as user preferences and settings.
+ *
+ * On Unix platforms this is determined using the mechanisms described in
+ * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
+ * XDG Base Directory Specification</ulink>
+ *
+ * Return value: a string owned by GLib that must not be modified
+ * or freed.
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar*
+g_get_user_config_dir (void)
+{
+ gchar *config_dir;
+
+ G_LOCK (g_utils_global);
+
+ if (!g_user_config_dir)
+ {
+#ifdef G_OS_WIN32
+ config_dir = get_special_folder (CSIDL_APPDATA);
+#else
+ config_dir = (gchar *) g_getenv ("XDG_CONFIG_HOME");
+
+ if (config_dir && config_dir[0])
+ config_dir = g_strdup (config_dir);
+#endif
+ if (!config_dir || !config_dir[0])
+ {
+ if (g_get_home_dir())
+ config_dir = g_build_filename (g_get_home_dir(), ".config", NULL);
+ else
+ config_dir = g_build_filename (g_get_tmp_dir(), g_get_user_name(), ".config", NULL);
+ }
+ g_user_config_dir = config_dir;
+ }
+ else
+ config_dir = g_user_config_dir;
+
+ G_UNLOCK (g_utils_global);
+
+ return config_dir;
+}
+
+/**
+ * g_get_user_cache_dir:
+ *
+ * Returns a base directory in which to store non-essential, cached
+ * data specific to particular user.
+ *
+ * On Unix platforms this is determined using the mechanisms described in
+ * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
+ * XDG Base Directory Specification</ulink>
+ *
+ * Return value: a string owned by GLib that must not be modified
+ * or freed.
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar*
+g_get_user_cache_dir (void)
+{
+ gchar *cache_dir;
+
+ G_LOCK (g_utils_global);
+
+ if (!g_user_cache_dir)
+ {
+#ifdef G_OS_WIN32
+ cache_dir = get_special_folder (CSIDL_INTERNET_CACHE); /* XXX correct? */
+#else
+ cache_dir = (gchar *) g_getenv ("XDG_CACHE_HOME");
+
+ if (cache_dir && cache_dir[0])
+ cache_dir = g_strdup (cache_dir);
+#endif
+ if (!cache_dir || !cache_dir[0])
+ {
+ if (g_get_home_dir())
+ cache_dir = g_build_filename (g_get_home_dir(), ".cache", NULL);
+ else
+ cache_dir = g_build_filename (g_get_tmp_dir(), g_get_user_name(), ".cache", NULL);
+ }
+ g_user_cache_dir = cache_dir;
+ }
+ else
+ cache_dir = g_user_cache_dir;
+
+ G_UNLOCK (g_utils_global);
+
+ return cache_dir;
+}
+
+/**
+ * g_get_system_data_dirs:
+ *
+ * Returns an ordered list of base directories in which to access
+ * system-wide application data.
+ *
+ * On Unix platforms this is determined using the mechanisms described in
+ * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
+ * XDG Base Directory Specification</ulink>
+ *
+ * Return value: a %NULL-terminated array of strings owned by GLib that must
+ * not be modified or freed.
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar * G_CONST_RETURN *
+g_get_system_data_dirs (void)
+{
+ gchar *data_dirs, **data_dir_vector;
+
+ G_LOCK (g_utils_global);
+
+ if (!g_system_data_dirs)
+ {
+#ifdef G_OS_WIN32
+ char *appdata = get_special_folder (CSIDL_COMMON_APPDATA);
+ char *docs = get_special_folder (CSIDL_COMMON_DOCUMENTS);
+
+ if (appdata && docs)
+ {
+ data_dirs = g_strconcat (appdata,
+ G_SEARCHPATH_SEPARATOR_S,
+ docs,
+ NULL);
+ g_free (appdata);
+ g_free (docs);
+ }
+ else if (appdata)
+ data_dirs = appdata;
+ else if (docs)
+ data_dirs = docs;
+ else
+ data_dirs = NULL;
+
+ if (data_dirs)
+ {
+ data_dir_vector = g_strsplit (data_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
+ g_free (data_dirs);
+ }
+ else
+ {
+ /* Punt, return empty list */
+ data_dir_vector = g_strsplit ("", G_SEARCHPATH_SEPARATOR_S, 0);
+ }
+#else
+ data_dirs = (gchar *) g_getenv ("XDG_DATA_DIRS");
+
+ if (!data_dirs || !data_dirs[0])
+ data_dirs = "/usr/local/share/:/usr/share/";
+
+ data_dir_vector = g_strsplit (data_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
+#endif
+
+ g_system_data_dirs = data_dir_vector;
+ }
+ else
+ data_dir_vector = g_system_data_dirs;
+
+ G_UNLOCK (g_utils_global);
+
+ return (G_CONST_RETURN gchar * G_CONST_RETURN *) data_dir_vector;
+}
+
+/**
+ * g_get_system_config_dirs:
+ *
+ * Returns an ordered list of base directories in which to access
+ * system-wide configuration information.
+ *
+ * On Unix platforms this is determined using the mechanisms described in
+ * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
+ * XDG Base Directory Specification</ulink>
+ *
+ * Return value: a %NULL-terminated array of strings owned by GLib that must
+ * not be modified or freed.
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar * G_CONST_RETURN *
+g_get_system_config_dirs (void)
+{
+ gchar *conf_dirs, **conf_dir_vector;
+
+ G_LOCK (g_utils_global);
+
+ if (!g_system_config_dirs)
+ {
+#ifdef G_OS_WIN32
+ conf_dirs = get_special_folder (CSIDL_COMMON_APPDATA);
+ if (conf_dirs)
+ {
+ conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
+ g_free (conf_dirs);
+ }
+ else
+ {
+ /* Return empty list */
+ conf_dir_vector = g_strsplit ("", G_SEARCHPATH_SEPARATOR_S, 0);
+ }
+#else
+ conf_dirs = (gchar *) g_getenv ("XDG_CONFIG_DIRS");
+
+ if (!conf_dirs || !conf_dirs[0])
+ conf_dirs = "/etc/xdg";
+
+ conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
+#endif
+
+ g_system_config_dirs = conf_dir_vector;
+ }
+ else
+ conf_dir_vector = g_system_config_dirs;
+ G_UNLOCK (g_utils_global);
+
+ return (G_CONST_RETURN gchar * G_CONST_RETURN *) conf_dir_vector;
+}
+
+static GHashTable *alias_table = NULL;
+
+/* read an alias file for the locales */
+static void
+read_aliases (gchar *file)
+{
+ FILE *fp;
+ char buf[256];
+
+ if (!alias_table)
+ alias_table = g_hash_table_new (g_str_hash, g_str_equal);
+ fp = fopen (file,"r");
+ if (!fp)
+ return;
+ while (fgets (buf, 256, fp))
+ {
+ char *p, *q;
+
+ g_strstrip (buf);
+
+ /* Line is a comment */
+ if ((buf[0] == '#') || (buf[0] == '\0'))
+ continue;
+
+ /* Reads first column */
+ for (p = buf, q = NULL; *p; p++) {
+ if ((*p == '\t') || (*p == ' ') || (*p == ':')) {
+ *p = '\0';
+ q = p+1;
+ while ((*q == '\t') || (*q == ' ')) {
+ q++;
+ }
+ break;
+ }
+ }
+ /* The line only had one column */
+ if (!q || *q == '\0')
+ continue;
+
+ /* Read second column */
+ for (p = q; *p; p++) {
+ if ((*p == '\t') || (*p == ' ')) {
+ *p = '\0';
+ break;
+ }
+ }
+
+ /* Add to alias table if necessary */
+ if (!g_hash_table_lookup (alias_table, buf)) {
+ g_hash_table_insert (alias_table, g_strdup (buf), g_strdup (q));
+ }
+ }
+ fclose (fp);
+}
+
+static char *
+unalias_lang (char *lang)
+{
+ char *p;
+ int i;
+
+ if (!alias_table)
+ read_aliases ("/usr/share/locale/locale.alias");
+
+ i = 0;
+ while ((p = g_hash_table_lookup (alias_table, lang)) && (strcmp (p, lang) != 0))
+ {
+ lang = p;
+ if (i++ == 30)
+ {
+ static gboolean said_before = FALSE;
+ if (!said_before)
+ g_warning ("Too many alias levels for a locale, "
+ "may indicate a loop");
+ said_before = TRUE;
+ return lang;
+ }
+ }
+ return lang;
+}
+
+/* Mask for components of locale spec. The ordering here is from
+ * least significant to most significant
+ */
+enum
+{
+ COMPONENT_CODESET = 1 << 0,
+ COMPONENT_TERRITORY = 1 << 1,
+ COMPONENT_MODIFIER = 1 << 2
+};
+
+/* Break an X/Open style locale specification into components
+ */
+static guint
+explode_locale (const gchar *locale,
+ gchar **language,
+ gchar **territory,
+ gchar **codeset,
+ gchar **modifier)
+{
+ const gchar *uscore_pos;
+ const gchar *at_pos;
+ const gchar *dot_pos;
+
+ guint mask = 0;
+
+ uscore_pos = strchr (locale, '_');
+ dot_pos = strchr (uscore_pos ? uscore_pos : locale, '.');
+ at_pos = strchr (dot_pos ? dot_pos : (uscore_pos ? uscore_pos : locale), '@');
+
+ if (at_pos)
+ {
+ mask |= COMPONENT_MODIFIER;
+ *modifier = g_strdup (at_pos);
+ }
+ else
+ at_pos = locale + strlen (locale);
+
+ if (dot_pos)
+ {
+ mask |= COMPONENT_CODESET;
+ *codeset = g_strndup (dot_pos, at_pos - dot_pos);
+ }
+ else
+ dot_pos = at_pos;
+
+ if (uscore_pos)
+ {
+ mask |= COMPONENT_TERRITORY;
+ *territory = g_strndup (uscore_pos, dot_pos - uscore_pos);
+ }
+ else
+ uscore_pos = dot_pos;
+
+ *language = g_strndup (locale, uscore_pos - locale);
+
+ return mask;
+}
+
+/*
+ * Compute all interesting variants for a given locale name -
+ * by stripping off different components of the value.
+ *
+ * For simplicity, we assume that the locale is in
+ * X/Open format: language[_territory][.codeset][@modifier]
+ *
+ * TODO: Extend this to handle the CEN format (see the GNUlibc docs)
+ * as well. We could just copy the code from glibc wholesale
+ * but it is big, ugly, and complicated, so I'm reluctant
+ * to do so when this should handle 99% of the time...
+ */
+GSList *_g_compute_locale_variants (const gchar *locale);
+GSList *
+_g_compute_locale_variants (const gchar *locale)
+{
+ GSList *retval = NULL;
+
+ gchar *language;
+ gchar *territory;
+ gchar *codeset;
+ gchar *modifier;
+
+ guint mask;
+ guint i;
+
+ g_return_val_if_fail (locale != NULL, NULL);
+
+ mask = explode_locale (locale, &language, &territory, &codeset, &modifier);
+
+ /* Iterate through all possible combinations, from least attractive
+ * to most attractive.
+ */
+ for (i = 0; i <= mask; i++)
+ if ((i & ~mask) == 0)
+ {
+ gchar *val = g_strconcat (language,
+ (i & COMPONENT_TERRITORY) ? territory : "",
+ (i & COMPONENT_CODESET) ? codeset : "",
+ (i & COMPONENT_MODIFIER) ? modifier : "",
+ NULL);
+ retval = g_slist_prepend (retval, val);
+ }
+
+ g_free (language);
+ if (mask & COMPONENT_CODESET)
+ g_free (codeset);
+ if (mask & COMPONENT_TERRITORY)
+ g_free (territory);
+ if (mask & COMPONENT_MODIFIER)
+ g_free (modifier);
+
+ return retval;
+}
+
+/* The following is (partly) taken from the gettext package.
+ Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc. */
+
+static const gchar *
+guess_category_value (const gchar *category_name)
+{
+ const gchar *retval;
+
+ /* The highest priority value is the `LANGUAGE' environment
+ variable. This is a GNU extension. */
+ retval = g_getenv ("LANGUAGE");
+ if ((retval != NULL) && (retval[0] != '\0'))
+ return retval;
+
+ /* `LANGUAGE' is not set. So we have to proceed with the POSIX
+ methods of looking to `LC_ALL', `LC_xxx', and `LANG'. On some
+ systems this can be done by the `setlocale' function itself. */
+
+ /* Setting of LC_ALL overwrites all other. */
+ retval = g_getenv ("LC_ALL");
+ if ((retval != NULL) && (retval[0] != '\0'))
+ return retval;
+
+ /* Next comes the name of the desired category. */
+ retval = g_getenv (category_name);
+ if ((retval != NULL) && (retval[0] != '\0'))
+ return retval;
+
+ /* Last possibility is the LANG environment variable. */
+ retval = g_getenv ("LANG");
+ if ((retval != NULL) && (retval[0] != '\0'))
+ return retval;
+
+#ifdef G_PLATFORM_WIN32
+ /* g_win32_getlocale() first checks for LC_ALL, LC_MESSAGES and
+ * LANG, which we already did above. Oh well. The main point of
+ * calling g_win32_getlocale() is to get the thread's locale as used
+ * by Windows and the Microsoft C runtime (in the "English_United
+ * States" format) translated into the Unixish format.
+ */
+ retval = g_win32_getlocale ();
+ if ((retval != NULL) && (retval[0] != '\0'))
+ return retval;
+#endif
+
+ return NULL;
+}
+
+typedef struct _GLanguageNamesCache GLanguageNamesCache;
+
+struct _GLanguageNamesCache {
+ gchar *languages;
+ gchar **language_names;
+};
+
+static void
+language_names_cache_free (gpointer data)
+{
+ GLanguageNamesCache *cache = data;
+ g_free (cache->languages);
+ g_strfreev (cache->language_names);
+ g_free (cache);
+}
+
+/**
+ * g_get_language_names:
+ *
+ * Computes a list of applicable locale names, which can be used to
+ * e.g. construct locale-dependent filenames or search paths. The returned
+ * list is sorted from most desirable to least desirable and always contains
+ * the default locale "C".
+ *
+ * For example, if LANGUAGE=de:en_US, then the returned list is
+ * "de", "en_US", "en", "C".
+ *
+ * This function consults the environment variables <envar>LANGUAGE</envar>,
+ * <envar>LC_ALL</envar>, <envar>LC_MESSAGES</envar> and <envar>LANG</envar>
+ * to find the list of locales specified by the user.
+ *
+ * Return value: a %NULL-terminated array of strings owned by GLib
+ * that must not be modified or freed.
+ *
+ * Since: 2.6
+ **/
+G_CONST_RETURN gchar * G_CONST_RETURN *
+g_get_language_names (void)
+{
+ static GStaticPrivate cache_private = G_STATIC_PRIVATE_INIT;
+ GLanguageNamesCache *cache = g_static_private_get (&cache_private);
+ const gchar *value;
+
+ if (!cache)
+ {
+ cache = g_new0 (GLanguageNamesCache, 1);
+ g_static_private_set (&cache_private, cache, language_names_cache_free);
+ }
+
+ value = guess_category_value ("LC_MESSAGES");
+ if (!value)
+ value = "C";
+
+ if (!(cache->languages && strcmp (cache->languages, value) == 0))
+ {
+ gchar **languages;
+ gchar **alist, **a;
+ GSList *list, *l;
+ gint i;
+
+ g_free (cache->languages);
+ g_strfreev (cache->language_names);
+ cache->languages = g_strdup (value);
+
+ alist = g_strsplit (value, ":", 0);
+ list = NULL;
+ for (a = alist; *a; a++)
+ {
+ gchar *b = unalias_lang (*a);
+ list = g_slist_concat (list, _g_compute_locale_variants (b));
+ }
+ g_strfreev (alist);
+ list = g_slist_append (list, g_strdup ("C"));
+
+ cache->language_names = languages = g_new (gchar *, g_slist_length (list) + 1);
+ for (l = list, i = 0; l; l = l->next, i++)
+ languages[i] = l->data;
+ languages[i] = NULL;
+
+ g_slist_free (list);
+ }
+
+ return (G_CONST_RETURN gchar * G_CONST_RETURN *) cache->language_names;
+}
+
+guint
+g_direct_hash (gconstpointer v)
+{
+ return GPOINTER_TO_UINT (v);
+}
+
+gboolean
+g_direct_equal (gconstpointer v1,
+ gconstpointer v2)
+{
+ return v1 == v2;
+}
+
+gboolean
+g_int_equal (gconstpointer v1,
+ gconstpointer v2)
+{
+ return *((const gint*) v1) == *((const gint*) v2);
+}
+
+guint
+g_int_hash (gconstpointer v)
+{
+ return *(const gint*) v;
+}
+
+/**
+ * g_nullify_pointer:
+ * @nullify_location: the memory address of the pointer.
+ *
+ * Set the pointer at the specified location to %NULL.
+ **/
+void
+g_nullify_pointer (gpointer *nullify_location)
+{
+ g_return_if_fail (nullify_location != NULL);
+
+ *nullify_location = NULL;
+}
+
+#if 0
+/**
+ * g_get_codeset:
+ *
+ * Get the codeset for the current locale.
+ *
+ * Return value: a newly allocated string containing the name
+ * of the codeset. This string must be freed with g_free().
+ **/
+gchar *
+g_get_codeset (void)
+{
+ const gchar *charset;
+
+ g_get_charset (&charset);
+
+ return g_strdup (charset);
+}
+
+/* This is called from g_thread_init(). It's used to
+ * initialize some static data in a threadsafe way.
+ */
+void
+_g_utils_thread_init (void)
+{
+ g_get_language_names ();
+}
+#endif
+
+#ifdef ENABLE_NLS
+
+#include <libintl.h>
+
+#ifdef G_PLATFORM_WIN32
+
+G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)
+
+static const gchar *
+_glib_get_locale_dir (void)
+{
+ static const gchar *cache = NULL;
+ if (cache == NULL)
+ cache = g_win32_get_package_installation_subdirectory
+ (GETTEXT_PACKAGE, dll_name, "lib\\locale");
+
+ return cache;
+}
+
+#undef GLIB_LOCALE_DIR
+#define GLIB_LOCALE_DIR _glib_get_locale_dir ()
+
+#endif /* G_PLATFORM_WIN32 */
+
+#if 0
+G_CONST_RETURN gchar *
+_glib_gettext (const gchar *str)
+{
+ static gboolean _glib_gettext_initialized = FALSE;
+
+ if (!_glib_gettext_initialized)
+ {
+ bindtextdomain(GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
+# ifdef HAVE_BIND_TEXTDOMAIN_CODESET
+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+# endif
+ _glib_gettext_initialized = TRUE;
+ }
+
+ return dgettext (GETTEXT_PACKAGE, str);
+}
+#endif
+
+#endif /* ENABLE_NLS */
+
+#if 0
+#define __G_UTILS_C__
+#include "galiasdef.c"
+#endif
More information about the gnucash-changes
mailing list