* MT safe for the unix part, FIXME: make the win32 part MT safe as well.
*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "config.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#define G_IMPLEMENT_INLINES 1
#define __G_UTILS_C__
#include "glib.h"
+#include "gprintfint.h"
#ifdef MAXPATHLEN
#define G_PATH_LENGTH MAXPATHLEN
#endif
#ifdef G_PLATFORM_WIN32
-# define STRICT /* Strict typing, please */
+# define STRICT /* Strict typing, please */
# include <windows.h>
# undef STRICT
+# include <lmcons.h> /* For UNLEN */
# include <ctype.h>
#endif /* G_PLATFORM_WIN32 */
#include <langinfo.h>
#endif
+#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
+#include <libintl.h>
+#endif
+
+/* G_IS_DIR_SEPARATOR probably should be made public in GLib 2.4 */
+#ifdef G_OS_WIN32
+#define G_IS_DIR_SEPARATOR(c) (c == G_DIR_SEPARATOR || c == '/')
+#else
+#define G_IS_DIR_SEPARATOR(c) (c == G_DIR_SEPARATOR)
+#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;
const guint glib_interface_age = GLIB_INTERFACE_AGE;
const guint glib_binary_age = GLIB_BINARY_AGE;
+/**
+ * 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.@required_micro. Second
+ * the running library must be binary compatible with the
+ * version @required_major.required_minor.@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 (required_effective_micro < glib_effective_micro - GLIB_BINARY_AGE)
+ return "GLib version too new (micro mismatch)";
+ if (required_effective_micro > glib_effective_micro)
+ return "GLib version too old (micro mismatch)";
+ return NULL;
+}
+
#if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
void
g_memmove (gpointer dest, gconstpointer src, gulong len)
#ifdef G_OS_WIN32
-gchar *inner_find_program_in_path (const gchar *program);
+static gchar *inner_find_program_in_path (const gchar *program);
gchar*
g_find_program_in_path (const gchar *program)
*
* Return value: absolute path, or NULL
**/
+#ifdef G_OS_WIN32
+static
+#endif
gchar*
g_find_program_in_path (const gchar *program)
{
* don't look in PATH.
*/
if (g_path_is_absolute (program)
- || strchr (program, G_DIR_SEPARATOR) != NULL)
+ || strchr (program, G_DIR_SEPARATOR) != NULL
+#ifdef G_OS_WIN32
+ || strchr (program, '/') != NULL
+#endif
+ )
{
if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE))
return g_strdup (program);
return NULL;
}
-gint
-g_snprintf (gchar *str,
- gulong n,
- gchar const *fmt,
- ...)
-{
-#ifdef HAVE_VSNPRINTF
- va_list args;
- gint retval;
-
- g_return_val_if_fail (str != NULL, 0);
- g_return_val_if_fail (n > 0, 0);
- g_return_val_if_fail (fmt != NULL, 0);
-
- va_start (args, fmt);
- retval = vsnprintf (str, n, fmt, args);
- va_end (args);
-
- if (retval < 0)
- {
- str[n-1] = '\0';
- retval = strlen (str);
- }
-
- return retval;
-#else /* !HAVE_VSNPRINTF */
- gchar *printed;
- va_list args;
-
- g_return_val_if_fail (str != NULL, 0);
- g_return_val_if_fail (n > 0, 0);
- g_return_val_if_fail (fmt != NULL, 0);
-
- va_start (args, fmt);
- printed = g_strdup_vprintf (fmt, args);
- va_end (args);
-
- strncpy (str, printed, n);
- str[n-1] = '\0';
-
- g_free (printed);
-
- return strlen (str);
-#endif /* !HAVE_VSNPRINTF */
-}
-
-gint
-g_vsnprintf (gchar *str,
- gulong n,
- gchar const *fmt,
- va_list args)
-{
-#ifdef HAVE_VSNPRINTF
- gint retval;
-
- g_return_val_if_fail (str != NULL, 0);
- g_return_val_if_fail (n > 0, 0);
- g_return_val_if_fail (fmt != NULL, 0);
-
- retval = vsnprintf (str, n, fmt, args);
-
- if (retval < 0)
- {
- str[n-1] = '\0';
- retval = strlen (str);
- }
-
- return retval;
-#else /* !HAVE_VSNPRINTF */
- gchar *printed;
-
- g_return_val_if_fail (str != NULL, 0);
- g_return_val_if_fail (n > 0, 0);
- g_return_val_if_fail (fmt != NULL, 0);
-
- printed = g_strdup_vprintf (fmt, args);
- strncpy (str, printed, n);
- str[n-1] = '\0';
-
- g_free (printed);
-
- return strlen (str);
-#endif /* !HAVE_VSNPRINTF */
-}
-
guint
g_parse_debug_string (const gchar *string,
const GDebugKey *keys,
return result;
}
+/**
+ * g_basename:
+ * @file_name: the name of the file.
+ *
+ * Gets the name of the file without any leading directory components.
+ * It returns a pointer into the given file name string.
+ *
+ * Return value: the name of the file without any leading directory components.
+ *
+ * Deprecated: Use g_path_get_basename() instead, but notice that
+ * g_path_get_basename() allocates new memory for the returned string, unlike
+ * this function which returns a pointer into the argument.
+ **/
G_CONST_RETURN gchar*
g_basename (const gchar *file_name)
{
g_return_val_if_fail (file_name != NULL, NULL);
base = strrchr (file_name, G_DIR_SEPARATOR);
+
+#ifdef G_OS_WIN32
+ {
+ gchar *q = strrchr (file_name, '/');
+ if (base == NULL || (q != NULL && q > base))
+ base = q;
+ }
+#endif
+
if (base)
return base + 1;
return (gchar*) file_name;
}
+/**
+ * g_path_get_basename:
+ * @file_name: the name of the file.
+ *
+ * Gets the last component of the filename. If @file_name ends with a
+ * directory separator it gets the component before the last slash. If
+ * @file_name consists only of directory separators (and on Windows,
+ * possibly a drive letter), a single separator is returned. If
+ * @file_name is empty, it gets ".".
+ *
+ * Return value: a newly allocated string containing the last component of
+ * the filename.
+ */
gchar*
g_path_get_basename (const gchar *file_name)
{
last_nonslash = strlen (file_name) - 1;
- while (last_nonslash >= 0 && file_name [last_nonslash] == G_DIR_SEPARATOR)
+ while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash]))
last_nonslash--;
if (last_nonslash == -1)
base = last_nonslash;
- while (base >=0 && file_name [base] != G_DIR_SEPARATOR)
+ while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base]))
base--;
#ifdef G_OS_WIN32
{
g_return_val_if_fail (file_name != NULL, FALSE);
- if (file_name[0] == G_DIR_SEPARATOR
-#ifdef G_OS_WIN32
- || file_name[0] == '/'
-#endif
- )
+ if (G_IS_DIR_SEPARATOR (file_name[0]))
return TRUE;
#ifdef G_OS_WIN32
/* Recognize drive letter on native Windows */
- if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && (file_name[2] == G_DIR_SEPARATOR || file_name[2] == '/'))
+ if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
return TRUE;
#endif /* G_OS_WIN32 */
g_return_val_if_fail (file_name != NULL, NULL);
#ifdef G_PLATFORM_WIN32
- /* Skip \\server\share (Win32) or //server/share (Cygwin) */
- if (file_name[0] == G_DIR_SEPARATOR &&
- file_name[1] == G_DIR_SEPARATOR &&
+ /* Skip \\server\share or //server/share */
+ if (G_IS_DIR_SEPARATOR (file_name[0]) &&
+ G_IS_DIR_SEPARATOR (file_name[1]) &&
file_name[2])
{
gchar *p;
- if ((p = strchr (file_name + 2, G_DIR_SEPARATOR)) > file_name + 2 &&
+ p = strchr (file_name + 2, G_DIR_SEPARATOR);
+#ifdef G_OS_WIN32
+ {
+ gchar *q = strchr (file_name + 2, '/');
+ if (p == NULL || (q != NULL && q < p))
+ p = q;
+ }
+#endif
+ if (p &&
+ p > file_name + 2 &&
p[1])
{
file_name = p + 1;
- while (file_name[0] && file_name[0] != G_DIR_SEPARATOR)
+ while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0]))
file_name++;
/* Possibly skip a backslash after the share name */
- if (file_name[0] == G_DIR_SEPARATOR)
+ if (G_IS_DIR_SEPARATOR (file_name[0]))
file_name++;
return (gchar *)file_name;
#endif
/* Skip initial slashes */
- if (file_name[0] == G_DIR_SEPARATOR)
+ if (G_IS_DIR_SEPARATOR (file_name[0]))
{
- while (file_name[0] == G_DIR_SEPARATOR)
+ while (G_IS_DIR_SEPARATOR (file_name[0]))
file_name++;
return (gchar *)file_name;
}
#ifdef G_OS_WIN32
/* Skip X:\ */
- if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
+ if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
return (gchar *)file_name + 3;
#endif
g_return_val_if_fail (file_name != NULL, NULL);
base = strrchr (file_name, G_DIR_SEPARATOR);
+#ifdef G_OS_WIN32
+ {
+ gchar *q = strrchr (file_name, '/');
+ if (base == NULL || (q != NULL && q > base))
+ base = q;
+ }
+#endif
if (!base)
+ {
+#ifdef G_OS_WIN32
+ if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
+ {
+ gchar drive_colon_dot[4];
+
+ drive_colon_dot[0] = file_name[0];
+ drive_colon_dot[1] = ':';
+ drive_colon_dot[2] = '.';
+ drive_colon_dot[3] = '\0';
+
+ return g_strdup (drive_colon_dot);
+ }
+#endif
return g_strdup (".");
- while (base > file_name && *base == G_DIR_SEPARATOR)
+ }
+
+ while (base > file_name && G_IS_DIR_SEPARATOR (*base))
base--;
+
+#ifdef G_OS_WIN32
+ if (base == file_name + 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
+ base++;
+#endif
+
len = (guint) 1 + base - file_name;
base = g_new (gchar, len + 1);
return dir;
}
+/**
+ * g_getenv:
+ * @variable: the environment variable to get.
+ *
+ * Returns an environment variable.
+ *
+ * Return value: the value of the environment variable, or %NULL if the environment
+ * variable is not found. The returned string may be overwritten by the next call to g_getenv(),
+ * g_setenv() or g_unsetenv().
+ **/
G_CONST_RETURN gchar*
g_getenv (const gchar *variable)
{
return getenv (variable);
#else
- G_LOCK_DEFINE_STATIC (getenv);
- struct env_struct
- {
- gchar *key;
- gchar *value;
- } *env;
- static GArray *environs = NULL;
+ GQuark quark;
gchar *system_env;
- guint length, i;
+ gchar *expanded_env;
+ guint length;
gchar dummy[2];
g_return_val_if_fail (variable != NULL, NULL);
- G_LOCK (getenv);
-
- if (!environs)
- environs = g_array_new (FALSE, FALSE, sizeof (struct env_struct));
-
- /* First we try to find the envinronment variable inside the already
- * found ones.
+ system_env = getenv (variable);
+ if (!system_env)
+ return NULL;
+
+ /* On Windows NT, it is relatively typical that environment
+ * variables contain references to other environment variables. If
+ * so, use ExpandEnvironmentStrings(). (If all software was written
+ * in the best possible way, such environment variables would be
+ * stored in the Registry as REG_EXPAND_SZ type values, and would
+ * then get automatically expanded before the program sees them. But
+ * there is broken software that stores environment variables as
+ * REG_SZ values even if they contain references to other
+ * environment variables.
*/
- for (i = 0; i < environs->len; i++)
+ if (strchr (system_env, '%') == NULL)
{
- env = &g_array_index (environs, struct env_struct, i);
- if (strcmp (env->key, variable) == 0)
- {
- g_assert (env->value);
- G_UNLOCK (getenv);
- return env->value;
- }
+ /* No reference to other variable(s), return value as such. */
+ return system_env;
}
- /* If not found, we ask the system */
+ /* First check how much space we need */
+ length = ExpandEnvironmentStrings (system_env, dummy, 2);
+
+ expanded_env = g_malloc (length);
+
+ ExpandEnvironmentStrings (system_env, expanded_env, length);
+
+ quark = g_quark_from_string (expanded_env);
+ g_free (expanded_env);
+
+ return g_quark_to_string (quark);
+#endif
+}
- system_env = getenv (variable);
- if (!system_env)
- {
- G_UNLOCK (getenv);
- return NULL;
- }
+/**
+ * g_setenv:
+ * @variable: the environment variable to set, must not contain '='.
+ * @value: the value for to set the variable to.
+ * @overwrite: whether to change the variable if it already exists.
+ *
+ * Sets an environment variable.
+ *
+ * Note that on some systems, the memory used for the variable and its value
+ * can't be reclaimed later.
+ *
+ * Returns: %FALSE if the environment variable couldn't be set.
+ *
+ * Since: 2.4
+ */
+gboolean
+g_setenv (const gchar *variable,
+ const gchar *value,
+ gboolean overwrite)
+{
+ gint result;
+#ifndef HAVE_SETENV
+ gchar *string;
+#endif
+
+ g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
- /* On Windows NT, it is relatively typical that environment variables
- * contain references to other environment variables. Handle that by
- * calling ExpandEnvironmentStrings.
+#ifdef HAVE_SETENV
+ result = setenv (variable, value, overwrite);
+#else
+ if (!overwrite && g_getenv (variable) != NULL)
+ return TRUE;
+
+ /* This results in a leak when you overwrite existing
+ * settings. It would be fairly easy to fix this by keeping
+ * our own parallel array or hash table.
*/
+ string = g_strconcat (variable, "=", value, NULL);
+ result = putenv (string);
+#endif
+ return result == 0;
+}
- g_array_set_size (environs, environs->len + 1);
+#ifndef HAVE_UNSETENV
+/* According to the Single Unix Specification, environ is not in
+ * any system header, although unistd.h often declares it.
+ */
+# ifndef _MSC_VER
+/*
+ * Win32 - at least msvc headers declare it so let's avoid
+ * warning C4273: '__p__environ' : inconsistent dll linkage. dllexport assumed.
+ */
+extern char **environ;
+# endif
+#endif
+
+/**
+ * g_unsetenv:
+ * @variable: the environment variable to remove, must not contain '='.
+ *
+ * Removes an environment variable from the environment.
+ *
+ * Note that on some systems, the memory used for the variable and its value
+ * can't be reclaimed. Furthermore, this function can't be guaranteed to operate in a
+ * threadsafe way.
+ *
+ * Since: 2.4
+ **/
+void
+g_unsetenv (const gchar *variable)
+{
+#ifdef HAVE_UNSETENV
+ g_return_if_fail (strchr (variable, '=') == NULL);
- env = &g_array_index (environs, struct env_struct, environs->len - 1);
+ unsetenv (variable);
+#else
+ int len;
+ gchar **e, **f;
- /* First check how much space we need */
- length = ExpandEnvironmentStrings (system_env, dummy, 2);
+ g_return_if_fail (strchr (variable, '=') == NULL);
- /* Then allocate that much, and actualy do the expansion and insert
- * the new found pair into our buffer
+ len = strlen (variable);
+
+ /* Mess directly with the environ array.
+ * This seems to be the only portable way to do this.
+ *
+ * Note that we remove *all* environment entries for
+ * the variable name, not just the first.
*/
-
- env->value = g_malloc (length);
- env->key = g_strdup (variable);
-
- ExpandEnvironmentStrings (system_env, env->value, length);
-
- G_UNLOCK (getenv);
- return env->value;
+ e = f = environ;
+ while (*e != NULL)
+ {
+ if (strncmp (*e, variable, len) != 0 || (*e)[len] != '=')
+ {
+ *f = *e;
+ f++;
+ }
+ e++;
+ }
+ *f = NULL;
#endif
}
-
G_LOCK_DEFINE_STATIC (g_utils_global);
static gchar *g_tmp_dir = NULL;
gsize k;
g_tmp_dir = g_strdup (P_tmpdir);
k = strlen (g_tmp_dir);
- if (k > 1 && g_tmp_dir[k - 1] == G_DIR_SEPARATOR)
+ if (k > 1 && G_IS_DIR_SEPARATOR (g_tmp_dir[k - 1]))
g_tmp_dir[k - 1] = '\0';
}
#endif
#endif /* G_OS_WIN32 */
}
- if (!g_home_dir)
- g_home_dir = g_strdup (g_getenv ("HOME"));
-
#ifdef G_OS_WIN32
+ /* We check $HOME first for Win32, though it is a last resort for Unix
+ * where we prefer the results of getpwuid().
+ */
+ {
+ gchar *home = g_getenv ("HOME");
+
+ /* Only believe HOME if it is an absolute path and exists */
+ if (home && g_path_is_absolute (home) && g_file_test (home, G_FILE_TEST_IS_DIR))
+ g_home_dir = g_strdup (home);
+ }
+
/* In case HOME is Unix-style (it happens), convert it to
* Windows style.
*/
error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
error = error < 0 ? errno : error;
# else /* HAVE_NONPOSIX_GETPWUID_R */
-# ifdef _AIX
+ /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
+# if defined(_AIX) || defined(__hpux)
error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
pw = error == 0 ? &pwd : NULL;
# else /* !_AIX */
}
if (pw)
{
- g_user_name = g_strdup (pw->pw_name);
- g_real_name = g_strdup (pw->pw_gecos);
+ g_user_name = g_strdup (pw->pw_name);
+
+ if (pw->pw_gecos && *pw->pw_gecos != '\0')
+ {
+ gchar **gecos_fields;
+ gchar **name_parts;
+
+ /* split the gecos field and substitute '&' */
+ gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
+ name_parts = g_strsplit (gecos_fields[0], "&", 0);
+ pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
+ g_real_name = g_strjoinv (pw->pw_name, name_parts);
+ g_strfreev (gecos_fields);
+ g_strfreev (name_parts);
+ }
+
if (!g_home_dir)
g_home_dir = g_strdup (pw->pw_dir);
}
# ifdef G_OS_WIN32
{
- guint len = 17;
- gchar buffer[17];
+ guint len = UNLEN+1;
+ gchar buffer[UNLEN+1];
if (GetUserName ((LPTSTR) buffer, (LPDWORD) &len))
{
}
}
# endif /* G_OS_WIN32 */
-
+
#endif /* !HAVE_PWD_H */
+
+ if (!g_home_dir)
+ g_home_dir = g_strdup (g_getenv ("HOME"));
#ifdef __EMX__
/* change '\\' in %HOME% to '/' */
g_user_name = g_strdup ("somebody");
if (!g_real_name)
g_real_name = g_strdup ("Unknown");
- else
- {
- gchar *p;
-
- for (p = g_real_name; *p; p++)
- if (*p == ',')
- {
- *p = 0;
- p = g_strdup (g_real_name);
- g_free (g_real_name);
- g_real_name = p;
- break;
- }
- }
}
}
return g_tmp_dir;
}
-G_LOCK_DEFINE (g_prgname);
+G_LOCK_DEFINE_STATIC (g_prgname);
static gchar *g_prgname = NULL;
gchar*
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");
+}
+
guint
g_direct_hash (gconstpointer v)
{
gchar *
g_get_codeset (void)
{
-#ifdef HAVE_CODESET
- char *result = nl_langinfo (CODESET);
- return g_strdup (result);
-#else
-#ifdef G_PLATFORM_WIN32
- return g_strdup_printf ("CP%d", GetACP ());
-#else
- /* FIXME: Do something more intelligent based on setlocale (LC_CTYPE, NULL)
- */
- return g_strdup ("ISO-8859-1");
-#endif
-#endif
+ const gchar *charset;
+
+ g_get_charset (&charset);
+
+ return g_strdup (charset);
}
#ifdef ENABLE_NLS
#include <libintl.h>
+#ifdef G_PLATFORM_WIN32
-#ifdef G_OS_WIN32
-
-/* DllMain function needed to tuck away the GLib DLL name */
-
-static char dll_name[MAX_PATH];
+G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)
-BOOL WINAPI
-DllMain (HINSTANCE hinstDLL,
- DWORD fdwReason,
- LPVOID lpvReserved)
+static const gchar *
+_glib_get_locale_dir (void)
{
- switch (fdwReason)
- {
- case DLL_PROCESS_ATTACH:
- GetModuleFileName ((HMODULE) hinstDLL, dll_name, sizeof (dll_name));
- break;
- }
+ static const gchar *cache = NULL;
+ if (cache == NULL)
+ cache = g_win32_get_package_installation_subdirectory
+ (GETTEXT_PACKAGE, dll_name, "lib\\locale");
- return TRUE;
+ return cache;
}
-/* On Windows we don't want any hard-coded path names */
-
#undef GLIB_LOCALE_DIR
-/* It's OK to leak the g_win32_get_...() and g_path_get_basename() results
- * below, as this macro is called only once.
- * Use the actual DLL name of the GLib DLL, i.e. don't assume the
- * GLib DLL has a certain name.
- */
-#define GLIB_LOCALE_DIR \
- g_win32_get_package_installation_subdirectory \
- (GETTEXT_PACKAGE, \
- g_path_get_basename (dll_name), \
- "share\\locale")
+#define GLIB_LOCALE_DIR _glib_get_locale_dir ()
-#endif /* !G_OS_WIN32 */
+#endif /* G_PLATFORM_WIN32 */
G_CONST_RETURN gchar *
_glib_gettext (const gchar *str)
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;
}
projects / platform / upstream / glib.git / blobdiff