* 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>
#include <sys/param.h>
#endif
-/* implement Glib's inline functions
+/* implement gutils's inline functions
*/
#define G_IMPLEMENT_INLINES 1
#define __G_UTILS_C__
#include "glib.h"
+#include "gprintfint.h"
#ifdef MAXPATHLEN
#define G_PATH_LENGTH MAXPATHLEN
#define G_PATH_LENGTH 2048
#endif
-#ifdef G_OS_WIN32
-# define STRICT /* Strict typing, please */
+#ifdef G_PLATFORM_WIN32
+# define STRICT /* Strict typing, please */
# include <windows.h>
# undef STRICT
+# include <lmcons.h> /* For UNLEN */
# include <ctype.h>
+#endif /* G_PLATFORM_WIN32 */
+
+#ifdef G_OS_WIN32
# include <direct.h>
-#endif /* G_OS_WIN32 */
+#endif
#ifdef HAVE_CODESET
#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);
#else
{
gchar *tmp;
- gchar moddir[PATH_MAX], sysdir[PATH_MAX], windir[PATH_MAX];
+ gchar moddir[MAXPATHLEN], sysdir[MAXPATHLEN], windir[MAXPATHLEN];
GetModuleFileName (NULL, moddir, sizeof (moddir));
tmp = g_path_get_dirname (moddir);
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,
- GDebugKey *keys,
- guint nkeys)
+g_parse_debug_string (const gchar *string,
+ const GDebugKey *keys,
+ guint nkeys)
{
guint i;
guint result = 0;
g_return_val_if_fail (string != NULL, 0);
- if (!g_strcasecmp (string, "all"))
+ if (!g_ascii_strcasecmp (string, "all"))
{
for (i=0; i<nkeys; i++)
result |= keys[i].value;
}
else
{
- gchar *str = g_strdup (string);
- gchar *p = str;
- gchar *q;
+ const gchar *p = string;
+ const gchar *q;
gboolean done = FALSE;
while (*p && !done)
done = TRUE;
}
- *q = 0;
-
for (i=0; i<nkeys; i++)
- if (!g_strcasecmp(keys[i].key, p))
+ if (g_ascii_strncasecmp(keys[i].key, p, q - p) == 0 &&
+ keys[i].key[q - p] == '\0')
result |= keys[i].value;
- p = q+1;
+ p = q + 1;
}
-
- g_free (str);
}
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)
{
register gchar *base;
-#if defined(G_ENABLE_DEBUG) && !defined(G_OS_WIN32)
- static gboolean first_call = TRUE;
-
- if (first_call)
- {
- g_message ("g_basename is deprecated. Use g_path_get_basename instead. "
- "Beware that the string returned by g_path_get_basename() has "
- " to be g_free()ed.");
- first_call = FALSE;
- }
-#endif /* G_ENABLE_DEBUG */
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;
#ifdef G_OS_WIN32
- if (isalpha (file_name[0]) && file_name[1] == ':')
+ if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
return (gchar*) file_name + 2;
#endif /* G_OS_WIN32 */
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)
{
- register gint base;
- register gint last_nonslash;
- guint len;
+ register gssize base;
+ register gssize last_nonslash;
+ gsize len;
gchar *retval;
g_return_val_if_fail (file_name != NULL, NULL);
-
+
if (file_name[0] == '\0')
/* empty string */
return g_strdup (".");
-
+
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)
return g_strdup (G_DIR_SEPARATOR_S);
#ifdef G_OS_WIN32
- if (last_nonslash == 1 && isalpha (file_name[0]) && file_name[1] == ':')
+ if (last_nonslash == 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
/* string only containing slashes and a drive */
return g_strdup (G_DIR_SEPARATOR_S);
#endif /* G_OS_WIN32 */
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
- if (base == -1 && isalpha (file_name[0]) && file_name[1] == ':')
+ if (base == -1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
base = 1;
#endif /* G_OS_WIN32 */
{
g_return_val_if_fail (file_name != NULL, FALSE);
- if (file_name[0] == G_DIR_SEPARATOR)
+ if (G_IS_DIR_SEPARATOR (file_name[0]))
return TRUE;
#ifdef G_OS_WIN32
- if (isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
+ /* Recognize drive letter on native Windows */
+ if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
return TRUE;
-#endif
+#endif /* G_OS_WIN32 */
return FALSE;
}
{
g_return_val_if_fail (file_name != NULL, NULL);
-#ifdef G_OS_WIN32
- /* Skip \\server\share */
- if (file_name[0] == G_DIR_SEPARATOR &&
- file_name[1] == G_DIR_SEPARATOR &&
+#ifdef G_PLATFORM_WIN32
+ /* 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, *q;
+ 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 (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_path_get_dirname (const gchar *file_name)
{
register gchar *base;
- register guint len;
+ register gsize len;
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);
}
gchar*
-g_dirname (const gchar *file_name)
-{
-#if defined(G_ENABLE_DEBUG) && !defined(G_OS_WIN32)
- static gboolean first_call = TRUE;
-
- if (first_call)
- {
- g_message ("g_dirname() is deprecated. Use g_path_get_dirname() instead.");
- first_call = FALSE;
- }
-#endif /* G_ENABLE_DEBUG */
-
- return g_path_get_dirname (file_name);
-}
-
-gchar*
g_get_current_dir (void)
{
gchar *buffer = NULL;
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
+}
+
+/**
+ * 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
- system_env = getenv (variable);
- if (!system_env)
- {
- G_UNLOCK (getenv);
- return NULL;
- }
+ 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;
#ifdef P_tmpdir
if (!g_tmp_dir)
{
- int k;
+ gsize k;
g_tmp_dir = g_strdup (P_tmpdir);
k = strlen (g_tmp_dir);
- if (g_tmp_dir[k-1] == G_DIR_SEPARATOR)
- g_tmp_dir[k-1] = '\0';
+ 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.
*/
{
struct passwd *pw = NULL;
gpointer buffer = NULL;
+ gint error;
# if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
struct passwd pwd;
# ifdef _SC_GETPW_R_SIZE_MAX
/* This reurns the maximum length */
- guint bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
+ glong bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
+
+ if (bufsize < 0)
+ bufsize = 64;
# else /* _SC_GETPW_R_SIZE_MAX */
- guint bufsize = 64;
+ glong bufsize = 64;
# endif /* _SC_GETPW_R_SIZE_MAX */
- gint error;
do
{
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_STATIC (g_prgname);
static gchar *g_prgname = NULL;
gchar*
{
gchar* retval;
- G_LOCK (g_utils_global);
+ G_LOCK (g_prgname);
retval = g_prgname;
- G_UNLOCK (g_utils_global);
+ G_UNLOCK (g_prgname);
return retval;
}
void
g_set_prgname (const gchar *prgname)
{
- gchar *c;
-
- G_LOCK (g_utils_global);
- c = g_prgname;
+ G_LOCK (g_prgname);
+ g_free (g_prgname);
g_prgname = g_strdup (prgname);
- g_free (c);
- G_UNLOCK (g_utils_global);
+ 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_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;
+}
+
+/**
* g_get_codeset:
*
* Get the codeset for the current locale.
gchar *
g_get_codeset (void)
{
-#ifdef HAVE_CODESET
- char *result = nl_langinfo (CODESET);
- return g_strdup (result);
-#else
-#ifndef G_OS_WIN32
- /* FIXME: Do something more intelligent based on setlocale (LC_CTYPE, NULL)
- */
- return g_strdup ("ISO-8859-1");
-#else
- return g_strdup_printf ("CP%d", GetACP ());
-#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
+G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)
-#define GLIB_LOCALE_DIR \
- g_win32_get_package_installation_subdirectory \
- (GETTEXT_PACKAGE, g_strdup_printf ("glib-%d.%d.dll", \
- GLIB_MAJOR_VERSION, \
- GLIB_MINOR_VERSION), \
- "locale")
+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");
-#endif /* G_OS_WIN32 */
+ return cache;
+}
+
+#undef GLIB_LOCALE_DIR
+#define GLIB_LOCALE_DIR _glib_get_locale_dir ()
+
+#endif /* G_PLATFORM_WIN32 */
G_CONST_RETURN gchar *
_glib_gettext (const gchar *str)
{
- gboolean _glib_gettext_initialized = FALSE;
+ 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;
}
}
#endif /* ENABLE_NLS */
-
-