1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1998 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GLib Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GLib at ftp://ftp.gtk.org/pub/gtk/.
28 * MT safe for the unix part, FIXME: make the win32 part MT safe as well.
45 #include <sys/types.h>
46 #ifdef HAVE_SYS_PARAM_H
47 #include <sys/param.h>
49 #ifdef HAVE_CRT_EXTERNS_H
50 #include <crt_externs.h> /* for _NSGetEnviron */
53 /* implement gutils's inline functions
55 #define G_IMPLEMENT_INLINES 1
58 #include "gprintfint.h"
59 #include "gthreadinit.h"
63 #define G_PATH_LENGTH MAXPATHLEN
64 #elif defined (PATH_MAX)
65 #define G_PATH_LENGTH PATH_MAX
66 #elif defined (_PC_PATH_MAX)
67 #define G_PATH_LENGTH sysconf(_PC_PATH_MAX)
69 #define G_PATH_LENGTH 2048
72 #ifdef G_PLATFORM_WIN32
73 # define STRICT /* Strict typing, please */
76 # ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
77 # define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2
78 # define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4
80 # include <lmcons.h> /* For UNLEN */
81 #endif /* G_PLATFORM_WIN32 */
86 /* older SDK (e.g. msvc 5.0) does not have these*/
87 # ifndef CSIDL_INTERNET_CACHE
88 # define CSIDL_INTERNET_CACHE 32
90 # ifndef CSIDL_COMMON_APPDATA
91 # define CSIDL_COMMON_APPDATA 35
93 # ifndef CSIDL_COMMON_DOCUMENTS
94 # define CSIDL_COMMON_DOCUMENTS 46
96 # ifndef CSIDL_PROFILE
97 # define CSIDL_PROFILE 40
103 #include <langinfo.h>
106 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
110 const guint glib_major_version
= GLIB_MAJOR_VERSION
;
111 const guint glib_minor_version
= GLIB_MINOR_VERSION
;
112 const guint glib_micro_version
= GLIB_MICRO_VERSION
;
113 const guint glib_interface_age
= GLIB_INTERFACE_AGE
;
114 const guint glib_binary_age
= GLIB_BINARY_AGE
;
116 #ifdef G_PLATFORM_WIN32
118 G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name
)
123 * glib_check_version:
124 * @required_major: the required major version.
125 * @required_minor: the required major version.
126 * @required_micro: the required major version.
128 * Checks that the GLib library in use is compatible with the
129 * given version. Generally you would pass in the constants
130 * #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION
131 * as the three arguments to this function; that produces
132 * a check that the library in use is compatible with
133 * the version of GLib the application or module was compiled
136 * Compatibility is defined by two things: first the version
137 * of the running library is newer than the version
138 * @required_major.required_minor.@required_micro. Second
139 * the running library must be binary compatible with the
140 * version @required_major.required_minor.@required_micro
141 * (same major version.)
143 * Return value: %NULL if the GLib library is compatible with the
144 * given version, or a string describing the version mismatch.
145 * The returned string is owned by GLib and must not be modified
151 glib_check_version (guint required_major
,
152 guint required_minor
,
153 guint required_micro
)
155 gint glib_effective_micro
= 100 * GLIB_MINOR_VERSION
+ GLIB_MICRO_VERSION
;
156 gint required_effective_micro
= 100 * required_minor
+ required_micro
;
158 if (required_major
> GLIB_MAJOR_VERSION
)
159 return "GLib version too old (major mismatch)";
160 if (required_major
< GLIB_MAJOR_VERSION
)
161 return "GLib version too new (major mismatch)";
162 if (required_effective_micro
< glib_effective_micro
- GLIB_BINARY_AGE
)
163 return "GLib version too new (micro mismatch)";
164 if (required_effective_micro
> glib_effective_micro
)
165 return "GLib version too old (micro mismatch)";
169 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
172 * @dest: the destination address to copy the bytes to.
173 * @src: the source address to copy the bytes from.
174 * @len: the number of bytes to copy.
176 * Copies a block of memory @len bytes long, from @src to @dest.
177 * The source and destination areas may overlap.
179 * In order to use this function, you must include
180 * <filename>string.h</filename> yourself, because this macro will
181 * typically simply resolve to memmove() and GLib does not include
182 * <filename>string.h</filename> for you.
185 g_memmove (gpointer dest
,
189 gchar
* destptr
= dest
;
190 const gchar
* srcptr
= src
;
191 if (src
+ len
< dest
|| dest
+ len
< src
)
193 bcopy (src
, dest
, len
);
196 else if (dest
<= src
)
199 *(destptr
++) = *(srcptr
++);
206 *(--destptr
) = *(--srcptr
);
209 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
217 * @func: the function to call on normal program termination.
219 * Specifies a function to be called at normal program termination.
221 * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
222 * macro that maps to a call to the atexit() function in the C
223 * library. This means that in case the code that calls g_atexit(),
224 * i.e. atexit(), is in a DLL, the function will be called when the
225 * DLL is detached from the program. This typically makes more sense
226 * than that the function is called when the GLib DLL is detached,
227 * which happened earlier when g_atexit() was a function in the GLib
230 * The behaviour of atexit() in the context of dynamically loaded
231 * modules is not formally specified and varies wildly.
233 * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
234 * loaded module which is unloaded before the program terminates might
235 * well cause a crash at program exit.
237 * Some POSIX systems implement atexit() like Windows, and have each
238 * dynamically loaded module maintain an own atexit chain that is
239 * called when the module is unloaded.
241 * On other POSIX systems, before a dynamically loaded module is
242 * unloaded, the registered atexit functions (if any) residing in that
243 * module are called, regardless where the code that registered them
244 * resided. This is presumably the most robust approach.
246 * As can be seen from the above, for portability it's best to avoid
247 * calling g_atexit() (or atexit()) except in the main executable of a
251 g_atexit (GVoidFunc func
)
254 const gchar
*error
= NULL
;
256 /* keep this in sync with glib.h */
258 #ifdef G_NATIVE_ATEXIT
259 result
= ATEXIT (func
);
261 error
= g_strerror (errno
);
262 #elif defined (HAVE_ATEXIT)
263 # ifdef NeXT /* @#%@! NeXTStep */
264 result
= !atexit ((void (*)(void)) func
);
266 error
= g_strerror (errno
);
268 result
= atexit ((void (*)(void)) func
);
270 error
= g_strerror (errno
);
272 #elif defined (HAVE_ON_EXIT)
273 result
= on_exit ((void (*)(int, void *)) func
, NULL
);
275 error
= g_strerror (errno
);
278 error
= "no implementation";
279 #endif /* G_NATIVE_ATEXIT */
282 g_error ("Could not register atexit() function: %s", error
);
285 /* Based on execvp() from GNU Libc.
286 * Some of this code is cut-and-pasted into gspawn.c
290 my_strchrnul (const gchar
*str
,
293 gchar
*p
= (gchar
*)str
;
294 while (*p
&& (*p
!= c
))
302 static gchar
*inner_find_program_in_path (const gchar
*program
);
305 g_find_program_in_path (const gchar
*program
)
307 const gchar
*last_dot
= strrchr (program
, '.');
309 if (last_dot
== NULL
||
310 strchr (last_dot
, '\\') != NULL
||
311 strchr (last_dot
, '/') != NULL
)
313 const gint program_length
= strlen (program
);
314 gchar
*pathext
= g_build_path (";",
315 ".exe;.cmd;.bat;.com",
316 g_getenv ("PATHEXT"),
319 gchar
*decorated_program
;
325 gchar
*q
= my_strchrnul (p
, ';');
327 decorated_program
= g_malloc (program_length
+ (q
-p
) + 1);
328 memcpy (decorated_program
, program
, program_length
);
329 memcpy (decorated_program
+program_length
, p
, q
-p
);
330 decorated_program
[program_length
+ (q
-p
)] = '\0';
332 retval
= inner_find_program_in_path (decorated_program
);
333 g_free (decorated_program
);
341 } while (*p
++ != '\0');
346 return inner_find_program_in_path (program
);
352 * g_find_program_in_path:
353 * @program: a program name in the GLib file name encoding
355 * Locates the first executable named @program in the user's path, in the
356 * same way that execvp() would locate it. Returns an allocated string
357 * with the absolute path name, or %NULL if the program is not found in
358 * the path. If @program is already an absolute path, returns a copy of
359 * @program if @program exists and is executable, and %NULL otherwise.
361 * On Windows, if @program does not have a file type suffix, tries
362 * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
363 * the <envar>PATHEXT</envar> environment variable.
365 * On Windows, it looks for the file in the same way as CreateProcess()
366 * would. This means first in the directory where the executing
367 * program was loaded from, then in the current directory, then in the
368 * Windows 32-bit system directory, then in the Windows directory, and
369 * finally in the directories in the <envar>PATH</envar> environment
370 * variable. If the program is found, the return value contains the
371 * full name including the type suffix.
373 * Return value: absolute path, or %NULL
377 inner_find_program_in_path (const gchar
*program
)
380 g_find_program_in_path (const gchar
*program
)
383 const gchar
*path
, *p
;
384 gchar
*name
, *freeme
;
386 const gchar
*path_copy
;
387 gchar
*filename
= NULL
, *appdir
= NULL
;
388 gchar
*sysdir
= NULL
, *windir
= NULL
;
393 g_return_val_if_fail (program
!= NULL
, NULL
);
395 /* If it is an absolute path, or a relative path including subdirectories,
396 * don't look in PATH.
398 if (g_path_is_absolute (program
)
399 || strchr (program
, G_DIR_SEPARATOR
) != NULL
401 || strchr (program
, '/') != NULL
405 if (g_file_test (program
, G_FILE_TEST_IS_EXECUTABLE
) &&
406 !g_file_test (program
, G_FILE_TEST_IS_DIR
))
407 return g_strdup (program
);
412 path
= g_getenv ("PATH");
413 #if defined(G_OS_UNIX) || defined(G_OS_BEOS)
416 /* There is no `PATH' in the environment. The default
417 * search path in GNU libc is the current directory followed by
418 * the path `confstr' returns for `_CS_PATH'.
421 /* In GLib we put . last, for security, and don't use the
422 * unportable confstr(); UNIX98 does not actually specify
423 * what to search if PATH is unset. POSIX may, dunno.
426 path
= "/bin:/usr/bin:.";
429 if (G_WIN32_HAVE_WIDECHAR_API ())
432 wchar_t wfilename
[MAXPATHLEN
], wsysdir
[MAXPATHLEN
],
435 n
= GetModuleFileNameW (NULL
, wfilename
, MAXPATHLEN
);
436 if (n
> 0 && n
< MAXPATHLEN
)
437 filename
= g_utf16_to_utf8 (wfilename
, -1, NULL
, NULL
, NULL
);
439 n
= GetSystemDirectoryW (wsysdir
, MAXPATHLEN
);
440 if (n
> 0 && n
< MAXPATHLEN
)
441 sysdir
= g_utf16_to_utf8 (wsysdir
, -1, NULL
, NULL
, NULL
);
443 n
= GetWindowsDirectoryW (wwindir
, MAXPATHLEN
);
444 if (n
> 0 && n
< MAXPATHLEN
)
445 windir
= g_utf16_to_utf8 (wwindir
, -1, NULL
, NULL
, NULL
);
450 gchar cpfilename
[MAXPATHLEN
], cpsysdir
[MAXPATHLEN
],
451 cpwindir
[MAXPATHLEN
];
453 n
= GetModuleFileNameA (NULL
, cpfilename
, MAXPATHLEN
);
454 if (n
> 0 && n
< MAXPATHLEN
)
455 filename
= g_locale_to_utf8 (cpfilename
, -1, NULL
, NULL
, NULL
);
457 n
= GetSystemDirectoryA (cpsysdir
, MAXPATHLEN
);
458 if (n
> 0 && n
< MAXPATHLEN
)
459 sysdir
= g_locale_to_utf8 (cpsysdir
, -1, NULL
, NULL
, NULL
);
461 n
= GetWindowsDirectoryA (cpwindir
, MAXPATHLEN
);
462 if (n
> 0 && n
< MAXPATHLEN
)
463 windir
= g_locale_to_utf8 (cpwindir
, -1, NULL
, NULL
, NULL
);
468 appdir
= g_path_get_dirname (filename
);
472 path
= g_strdup (path
);
476 const gchar
*tem
= path
;
477 path
= g_strconcat (windir
, ";", path
, NULL
);
478 g_free ((gchar
*) tem
);
484 const gchar
*tem
= path
;
485 path
= g_strconcat (sysdir
, ";", path
, NULL
);
486 g_free ((gchar
*) tem
);
491 const gchar
*tem
= path
;
492 path
= g_strconcat (".;", path
, NULL
);
493 g_free ((gchar
*) tem
);
498 const gchar
*tem
= path
;
499 path
= g_strconcat (appdir
, ";", path
, NULL
);
500 g_free ((gchar
*) tem
);
507 len
= strlen (program
) + 1;
508 pathlen
= strlen (path
);
509 freeme
= name
= g_malloc (pathlen
+ len
+ 1);
511 /* Copy the file name at the top, including '\0' */
512 memcpy (name
+ pathlen
+ 1, program
, len
);
513 name
= name
+ pathlen
;
514 /* And add the slash before the filename */
515 *name
= G_DIR_SEPARATOR
;
523 p
= my_strchrnul (path
, G_SEARCHPATH_SEPARATOR
);
526 /* Two adjacent colons, or a colon at the beginning or the end
527 * of `PATH' means to search the current directory.
531 startp
= memcpy (name
- (p
- path
), path
, p
- path
);
533 if (g_file_test (startp
, G_FILE_TEST_IS_EXECUTABLE
) &&
534 !g_file_test (startp
, G_FILE_TEST_IS_DIR
))
537 ret
= g_strdup (startp
);
540 g_free ((gchar
*) path_copy
);
545 while (*p
++ != '\0');
549 g_free ((gchar
*) path_copy
);
556 * g_parse_debug_string:
557 * @string: a list of debug options separated by ':' or "all"
559 * @keys: pointer to an array of #GDebugKey which associate
560 * strings with bit flags.
561 * @nkeys: the number of #GDebugKey<!-- -->s in the array.
563 * Parses a string containing debugging options separated
564 * by ':' into a %guint containing bit flags. This is used
565 * within GDK and GTK+ to parse the debug options passed on the
566 * command line or through environment variables.
568 * Returns: the combined set of bit flags.
571 g_parse_debug_string (const gchar
*string
,
572 const GDebugKey
*keys
,
578 g_return_val_if_fail (string
!= NULL
, 0);
580 if (!g_ascii_strcasecmp (string
, "all"))
582 for (i
=0; i
<nkeys
; i
++)
583 result
|= keys
[i
].value
;
587 const gchar
*p
= string
;
589 gboolean done
= FALSE
;
600 for (i
=0; i
<nkeys
; i
++)
601 if (g_ascii_strncasecmp (keys
[i
].key
, p
, q
- p
) == 0 &&
602 keys
[i
].key
[q
- p
] == '\0')
603 result
|= keys
[i
].value
;
614 * @file_name: the name of the file.
616 * Gets the name of the file without any leading directory components.
617 * It returns a pointer into the given file name string.
619 * Return value: the name of the file without any leading directory components.
621 * Deprecated: Use g_path_get_basename() instead, but notice that
622 * g_path_get_basename() allocates new memory for the returned string, unlike
623 * this function which returns a pointer into the argument.
625 G_CONST_RETURN gchar
*
626 g_basename (const gchar
*file_name
)
628 register gchar
*base
;
630 g_return_val_if_fail (file_name
!= NULL
, NULL
);
632 base
= strrchr (file_name
, G_DIR_SEPARATOR
);
636 gchar
*q
= strrchr (file_name
, '/');
637 if (base
== NULL
|| (q
!= NULL
&& q
> base
))
646 if (g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':')
647 return (gchar
*) file_name
+ 2;
648 #endif /* G_OS_WIN32 */
650 return (gchar
*) file_name
;
654 * g_path_get_basename:
655 * @file_name: the name of the file.
657 * Gets the last component of the filename. If @file_name ends with a
658 * directory separator it gets the component before the last slash. If
659 * @file_name consists only of directory separators (and on Windows,
660 * possibly a drive letter), a single separator is returned. If
661 * @file_name is empty, it gets ".".
663 * Return value: a newly allocated string containing the last component of
667 g_path_get_basename (const gchar
*file_name
)
669 register gssize base
;
670 register gssize last_nonslash
;
674 g_return_val_if_fail (file_name
!= NULL
, NULL
);
676 if (file_name
[0] == '\0')
678 return g_strdup (".");
680 last_nonslash
= strlen (file_name
) - 1;
682 while (last_nonslash
>= 0 && G_IS_DIR_SEPARATOR (file_name
[last_nonslash
]))
685 if (last_nonslash
== -1)
686 /* string only containing slashes */
687 return g_strdup (G_DIR_SEPARATOR_S
);
690 if (last_nonslash
== 1 && g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':')
691 /* string only containing slashes and a drive */
692 return g_strdup (G_DIR_SEPARATOR_S
);
693 #endif /* G_OS_WIN32 */
695 base
= last_nonslash
;
697 while (base
>=0 && !G_IS_DIR_SEPARATOR (file_name
[base
]))
701 if (base
== -1 && g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':')
703 #endif /* G_OS_WIN32 */
705 len
= last_nonslash
- base
;
706 retval
= g_malloc (len
+ 1);
707 memcpy (retval
, file_name
+ base
+ 1, len
);
713 * g_path_is_absolute:
714 * @file_name: a file name.
716 * Returns %TRUE if the given @file_name is an absolute file name,
717 * i.e. it contains a full path from the root directory such as "/usr/local"
718 * on UNIX or "C:\windows" on Windows systems.
720 * Returns: %TRUE if @file_name is an absolute path.
723 g_path_is_absolute (const gchar
*file_name
)
725 g_return_val_if_fail (file_name
!= NULL
, FALSE
);
727 if (G_IS_DIR_SEPARATOR (file_name
[0]))
731 /* Recognize drive letter on native Windows */
732 if (g_ascii_isalpha (file_name
[0]) &&
733 file_name
[1] == ':' && G_IS_DIR_SEPARATOR (file_name
[2]))
735 #endif /* G_OS_WIN32 */
742 * @file_name: a file name.
744 * Returns a pointer into @file_name after the root component, i.e. after
745 * the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute
746 * path it returns %NULL.
748 * Returns: a pointer into @file_name after the root component.
750 G_CONST_RETURN gchar
*
751 g_path_skip_root (const gchar
*file_name
)
753 g_return_val_if_fail (file_name
!= NULL
, NULL
);
755 #ifdef G_PLATFORM_WIN32
756 /* Skip \\server\share or //server/share */
757 if (G_IS_DIR_SEPARATOR (file_name
[0]) &&
758 G_IS_DIR_SEPARATOR (file_name
[1]) &&
760 !G_IS_DIR_SEPARATOR (file_name
[2]))
764 p
= strchr (file_name
+ 2, G_DIR_SEPARATOR
);
767 gchar
*q
= strchr (file_name
+ 2, '/');
768 if (p
== NULL
|| (q
!= NULL
&& q
< p
))
778 while (file_name
[0] && !G_IS_DIR_SEPARATOR (file_name
[0]))
781 /* Possibly skip a backslash after the share name */
782 if (G_IS_DIR_SEPARATOR (file_name
[0]))
785 return (gchar
*)file_name
;
790 /* Skip initial slashes */
791 if (G_IS_DIR_SEPARATOR (file_name
[0]))
793 while (G_IS_DIR_SEPARATOR (file_name
[0]))
795 return (gchar
*)file_name
;
800 if (g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':' && G_IS_DIR_SEPARATOR (file_name
[2]))
801 return (gchar
*)file_name
+ 3;
808 * g_path_get_dirname:
809 * @file_name: the name of the file.
811 * Gets the directory components of a file name. If the file name has no
812 * directory components "." is returned. The returned string should be
813 * freed when no longer needed.
815 * Returns: the directory components of the file.
818 g_path_get_dirname (const gchar
*file_name
)
820 register gchar
*base
;
823 g_return_val_if_fail (file_name
!= NULL
, NULL
);
825 base
= strrchr (file_name
, G_DIR_SEPARATOR
);
828 gchar
*q
= strrchr (file_name
, '/');
829 if (base
== NULL
|| (q
!= NULL
&& q
> base
))
836 if (g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':')
838 gchar drive_colon_dot
[4];
840 drive_colon_dot
[0] = file_name
[0];
841 drive_colon_dot
[1] = ':';
842 drive_colon_dot
[2] = '.';
843 drive_colon_dot
[3] = '\0';
845 return g_strdup (drive_colon_dot
);
848 return g_strdup (".");
851 while (base
> file_name
&& G_IS_DIR_SEPARATOR (*base
))
855 /* base points to the char before the last slash.
857 * In case file_name is the root of a drive (X:\) or a child of the
858 * root of a drive (X:\foo), include the slash.
860 * In case file_name is the root share of an UNC path
861 * (\\server\share), add a slash, returning \\server\share\ .
863 * In case file_name is a direct child of a share in an UNC path
864 * (\\server\share\foo), include the slash after the share name,
865 * returning \\server\share\ .
867 if (base
== file_name
+ 1 && g_ascii_isalpha (file_name
[0]) && file_name
[1] == ':')
869 else if (G_IS_DIR_SEPARATOR (file_name
[0]) &&
870 G_IS_DIR_SEPARATOR (file_name
[1]) &&
872 !G_IS_DIR_SEPARATOR (file_name
[2]) &&
873 base
>= file_name
+ 2)
875 const gchar
*p
= file_name
+ 2;
876 while (*p
&& !G_IS_DIR_SEPARATOR (*p
))
880 len
= (guint
) strlen (file_name
) + 1;
881 base
= g_new (gchar
, len
+ 1);
882 strcpy (base
, file_name
);
883 base
[len
-1] = G_DIR_SEPARATOR
;
887 if (G_IS_DIR_SEPARATOR (*p
))
890 while (*p
&& !G_IS_DIR_SEPARATOR (*p
))
898 len
= (guint
) 1 + base
- file_name
;
900 base
= g_new (gchar
, len
+ 1);
901 g_memmove (base
, file_name
, len
);
910 * Gets the current directory.
911 * The returned string should be freed when no longer needed. The encoding
912 * of the returned string is system defined. On Windows, it is always UTF-8.
914 * Returns: the current directory.
917 g_get_current_dir (void)
923 if (G_WIN32_HAVE_WIDECHAR_API ())
925 wchar_t dummy
[2], *wdir
;
928 len
= GetCurrentDirectoryW (2, dummy
);
929 wdir
= g_new (wchar_t, len
);
931 if (GetCurrentDirectoryW (len
, wdir
) == len
- 1)
932 dir
= g_utf16_to_utf8 (wdir
, -1, NULL
, NULL
, NULL
);
938 gchar dummy
[2], *cpdir
;
941 len
= GetCurrentDirectoryA (2, dummy
);
942 cpdir
= g_new (gchar
, len
);
944 if (GetCurrentDirectoryA (len
, cpdir
) == len
- 1)
945 dir
= g_locale_to_utf8 (cpdir
, -1, NULL
, NULL
, NULL
);
951 dir
= g_strdup ("\\");
957 gchar
*buffer
= NULL
;
959 static gulong max_len
= 0;
962 max_len
= (G_PATH_LENGTH
== -1) ? 2048 : G_PATH_LENGTH
;
964 /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
965 * and, if that wasn't bad enough, hangs in doing so.
967 #if (defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
968 buffer
= g_new (gchar
, max_len
+ 1);
970 dir
= getwd (buffer
);
971 #else /* !sun || !HAVE_GETCWD */
972 while (max_len
< G_MAXULONG
/ 2)
974 buffer
= g_new (gchar
, max_len
+ 1);
976 dir
= getcwd (buffer
, max_len
);
978 if (dir
|| errno
!= ERANGE
)
984 #endif /* !sun || !HAVE_GETCWD */
986 if (!dir
|| !*buffer
)
988 /* hm, should we g_error() out here?
989 * this can happen if e.g. "./" has mode \0000
991 buffer
[0] = G_DIR_SEPARATOR
;
995 dir
= g_strdup (buffer
);
1004 * @variable: the environment variable to get, in the GLib file name encoding.
1006 * Returns the value of an environment variable. The name and value
1007 * are in the GLib file name encoding. On UNIX, this means the actual
1008 * bytes which might or might not be in some consistent character set
1009 * and encoding. On Windows, it is in UTF-8. On Windows, in case the
1010 * environment variable's value contains references to other
1011 * environment variables, they are expanded.
1013 * Return value: the value of the environment variable, or %NULL if
1014 * the environment variable is not found. The returned string may be
1015 * overwritten by the next call to g_getenv(), g_setenv() or
1018 G_CONST_RETURN gchar
*
1019 g_getenv (const gchar
*variable
)
1023 g_return_val_if_fail (variable
!= NULL
, NULL
);
1025 return getenv (variable
);
1027 #else /* G_OS_WIN32 */
1032 g_return_val_if_fail (variable
!= NULL
, NULL
);
1033 g_return_val_if_fail (g_utf8_validate (variable
, -1, NULL
), NULL
);
1035 /* On Windows NT, it is relatively typical that environment
1036 * variables contain references to other environment variables. If
1037 * so, use ExpandEnvironmentStrings(). (In an ideal world, such
1038 * environment variables would be stored in the Registry as
1039 * REG_EXPAND_SZ type values, and would then get automatically
1040 * expanded before a program sees them. But there is broken software
1041 * that stores environment variables as REG_SZ values even if they
1042 * contain references to other environment variables.)
1045 if (G_WIN32_HAVE_WIDECHAR_API ())
1047 wchar_t dummy
[2], *wname
, *wvalue
;
1050 wname
= g_utf8_to_utf16 (variable
, -1, NULL
, NULL
, NULL
);
1052 len
= GetEnvironmentVariableW (wname
, dummy
, 2);
1062 wvalue
= g_new (wchar_t, len
);
1064 if (GetEnvironmentVariableW (wname
, wvalue
, len
) != len
- 1)
1071 if (wcschr (wvalue
, L
'%') != NULL
)
1073 wchar_t *tem
= wvalue
;
1075 len
= ExpandEnvironmentStringsW (wvalue
, dummy
, 2);
1079 wvalue
= g_new (wchar_t, len
);
1081 if (ExpandEnvironmentStringsW (tem
, wvalue
, len
) != len
)
1091 value
= g_utf16_to_utf8 (wvalue
, -1, NULL
, NULL
, NULL
);
1098 gchar dummy
[3], *cpname
, *cpvalue
;
1101 cpname
= g_locale_from_utf8 (variable
, -1, NULL
, NULL
, NULL
);
1103 g_return_val_if_fail (cpname
!= NULL
, NULL
);
1105 len
= GetEnvironmentVariableA (cpname
, dummy
, 2);
1115 cpvalue
= g_new (gchar
, len
);
1117 if (GetEnvironmentVariableA (cpname
, cpvalue
, len
) != len
- 1)
1124 if (strchr (cpvalue
, '%') != NULL
)
1126 gchar
*tem
= cpvalue
;
1128 len
= ExpandEnvironmentStringsA (cpvalue
, dummy
, 3);
1132 cpvalue
= g_new (gchar
, len
);
1134 if (ExpandEnvironmentStringsA (tem
, cpvalue
, len
) != len
)
1144 value
= g_locale_to_utf8 (cpvalue
, -1, NULL
, NULL
, NULL
);
1150 quark
= g_quark_from_string (value
);
1153 return g_quark_to_string (quark
);
1155 #endif /* G_OS_WIN32 */
1160 * @variable: the environment variable to set, must not contain '='.
1161 * @value: the value for to set the variable to.
1162 * @overwrite: whether to change the variable if it already exists.
1164 * Sets an environment variable. Both the variable's name and value
1165 * should be in the GLib file name encoding. On UNIX, this means that
1166 * they can be any sequence of bytes. On Windows, they should be in
1169 * Note that on some systems, when variables are overwritten, the memory
1170 * used for the previous variables and its value isn't reclaimed.
1172 * Returns: %FALSE if the environment variable couldn't be set.
1177 g_setenv (const gchar
*variable
,
1188 g_return_val_if_fail (variable
!= NULL
, FALSE
);
1189 g_return_val_if_fail (strchr (variable
, '=') == NULL
, FALSE
);
1192 result
= setenv (variable
, value
, overwrite
);
1194 if (!overwrite
&& getenv (variable
) != NULL
)
1197 /* This results in a leak when you overwrite existing
1198 * settings. It would be fairly easy to fix this by keeping
1199 * our own parallel array or hash table.
1201 string
= g_strconcat (variable
, "=", value
, NULL
);
1202 result
= putenv (string
);
1206 #else /* G_OS_WIN32 */
1210 g_return_val_if_fail (variable
!= NULL
, FALSE
);
1211 g_return_val_if_fail (strchr (variable
, '=') == NULL
, FALSE
);
1212 g_return_val_if_fail (g_utf8_validate (variable
, -1, NULL
), FALSE
);
1213 g_return_val_if_fail (g_utf8_validate (value
, -1, NULL
), FALSE
);
1215 if (!overwrite
&& g_getenv (variable
) != NULL
)
1218 /* We want to (if possible) set both the environment variable copy
1219 * kept by the C runtime and the one kept by the system.
1221 * We can't use only the C runtime's putenv or _wputenv() as that
1222 * won't work for arbitrary Unicode strings in a "non-Unicode" app
1223 * (with main() and not wmain()). In a "main()" app the C runtime
1224 * initializes the C runtime's environment table by converting the
1225 * real (wide char) environment variables to system codepage, thus
1226 * breaking those that aren't representable in the system codepage.
1228 * As the C runtime's putenv() will also set the system copy, we do
1229 * the putenv() first, then call SetEnvironmentValueW ourselves.
1232 if (G_WIN32_HAVE_WIDECHAR_API ())
1234 wchar_t *wname
= g_utf8_to_utf16 (variable
, -1, NULL
, NULL
, NULL
);
1235 wchar_t *wvalue
= g_utf8_to_utf16 (value
, -1, NULL
, NULL
, NULL
);
1236 gchar
*tem
= g_strconcat (variable
, "=", value
, NULL
);
1237 wchar_t *wassignment
= g_utf8_to_utf16 (tem
, -1, NULL
, NULL
, NULL
);
1240 _wputenv (wassignment
);
1241 g_free (wassignment
);
1243 retval
= (SetEnvironmentVariableW (wname
, wvalue
) != 0);
1250 /* In the non-Unicode case (Win9x), just putenv() is good
1253 gchar
*tem
= g_strconcat (variable
, "=", value
, NULL
);
1254 gchar
*cpassignment
= g_locale_from_utf8 (tem
, -1, NULL
, NULL
, NULL
);
1258 retval
= (putenv (cpassignment
) == 0);
1260 g_free (cpassignment
);
1265 #endif /* G_OS_WIN32 */
1268 #ifdef HAVE__NSGETENVIRON
1269 #define environ (*_NSGetEnviron())
1270 #elif !defined(G_OS_WIN32)
1272 /* According to the Single Unix Specification, environ is not in
1273 * any system header, although unistd.h often declares it.
1275 extern char **environ
;
1280 * @variable: the environment variable to remove, must not contain '='.
1282 * Removes an environment variable from the environment.
1284 * Note that on some systems, when variables are overwritten, the memory
1285 * used for the previous variables and its value isn't reclaimed.
1286 * Furthermore, this function can't be guaranteed to operate in a
1292 g_unsetenv (const gchar
*variable
)
1296 #ifdef HAVE_UNSETENV
1297 g_return_if_fail (variable
!= NULL
);
1298 g_return_if_fail (strchr (variable
, '=') == NULL
);
1300 unsetenv (variable
);
1301 #else /* !HAVE_UNSETENV */
1305 g_return_if_fail (variable
!= NULL
);
1306 g_return_if_fail (strchr (variable
, '=') == NULL
);
1308 len
= strlen (variable
);
1310 /* Mess directly with the environ array.
1311 * This seems to be the only portable way to do this.
1313 * Note that we remove *all* environment entries for
1314 * the variable name, not just the first.
1319 if (strncmp (*e
, variable
, len
) != 0 || (*e
)[len
] != '=')
1327 #endif /* !HAVE_UNSETENV */
1329 #else /* G_OS_WIN32 */
1331 g_return_if_fail (variable
!= NULL
);
1332 g_return_if_fail (strchr (variable
, '=') == NULL
);
1333 g_return_if_fail (g_utf8_validate (variable
, -1, NULL
));
1335 if (G_WIN32_HAVE_WIDECHAR_API ())
1337 wchar_t *wname
= g_utf8_to_utf16 (variable
, -1, NULL
, NULL
, NULL
);
1338 gchar
*tem
= g_strconcat (variable
, "=", NULL
);
1339 wchar_t *wassignment
= g_utf8_to_utf16 (tem
, -1, NULL
, NULL
, NULL
);
1342 _wputenv (wassignment
);
1343 g_free (wassignment
);
1345 SetEnvironmentVariableW (wname
, NULL
);
1351 /* In the non-Unicode case (Win9x), just putenv() is good
1354 gchar
*tem
= g_strconcat (variable
, "=", NULL
);
1355 gchar
*cpassignment
= g_locale_from_utf8 (tem
, -1, NULL
, NULL
, NULL
);
1359 putenv (cpassignment
);
1361 g_free (cpassignment
);
1364 #endif /* G_OS_WIN32 */
1370 * Gets the names of all variables set in the environment.
1372 * Returns: a %NULL-terminated list of strings which must be freed
1373 * with g_strfreev().
1380 gchar
**result
, *eq
;
1383 len
= g_strv_length (environ
);
1384 result
= g_new0 (gchar
*, len
+ 1);
1387 for (i
= 0; i
< len
; i
++)
1389 eq
= strchr (environ
[i
], '=');
1391 result
[j
++] = g_strndup (environ
[i
], eq
- environ
[i
]);
1399 G_LOCK_DEFINE_STATIC (g_utils_global
);
1401 static gchar
*g_tmp_dir
= NULL
;
1402 static gchar
*g_user_name
= NULL
;
1403 static gchar
*g_real_name
= NULL
;
1404 static gchar
*g_home_dir
= NULL
;
1405 static gchar
*g_host_name
= NULL
;
1408 /* System codepage versions of the above, kept at file level so that they,
1409 * too, are produced only once.
1411 static gchar
*g_tmp_dir_cp
= NULL
;
1412 static gchar
*g_user_name_cp
= NULL
;
1413 static gchar
*g_real_name_cp
= NULL
;
1414 static gchar
*g_home_dir_cp
= NULL
;
1417 static gchar
*g_user_data_dir
= NULL
;
1418 static gchar
**g_system_data_dirs
= NULL
;
1419 static gchar
*g_user_cache_dir
= NULL
;
1420 static gchar
*g_user_config_dir
= NULL
;
1421 static gchar
**g_system_config_dirs
= NULL
;
1426 get_special_folder (int csidl
)
1430 wchar_t wc
[MAX_PATH
+1];
1433 LPITEMIDLIST pidl
= NULL
;
1435 gchar
*retval
= NULL
;
1437 hr
= SHGetSpecialFolderLocation (NULL
, csidl
, &pidl
);
1440 if (G_WIN32_HAVE_WIDECHAR_API ())
1442 b
= SHGetPathFromIDListW (pidl
, path
.wc
);
1444 retval
= g_utf16_to_utf8 (path
.wc
, -1, NULL
, NULL
, NULL
);
1448 b
= SHGetPathFromIDListA (pidl
, path
.c
);
1450 retval
= g_locale_to_utf8 (path
.c
, -1, NULL
, NULL
, NULL
);
1452 CoTaskMemFree (pidl
);
1458 get_windows_directory_root (void)
1460 char windowsdir
[MAX_PATH
];
1462 if (GetWindowsDirectory (windowsdir
, sizeof (windowsdir
)))
1464 /* Usually X:\Windows, but in terminal server environments
1465 * might be an UNC path, AFAIK.
1467 char *p
= (char *) g_path_skip_root (windowsdir
);
1468 if (G_IS_DIR_SEPARATOR (p
[-1]) && p
[-2] != ':')
1471 return g_strdup (windowsdir
);
1474 return g_strdup ("C:\\");
1479 /* HOLDS: g_utils_global_lock */
1481 g_get_any_init_do (void)
1483 gchar hostname
[100];
1485 g_tmp_dir
= g_strdup (g_getenv ("TMPDIR"));
1487 g_tmp_dir
= g_strdup (g_getenv ("TMP"));
1489 g_tmp_dir
= g_strdup (g_getenv ("TEMP"));
1493 g_tmp_dir
= get_windows_directory_root ();
1499 g_tmp_dir
= g_strdup (P_tmpdir
);
1500 k
= strlen (g_tmp_dir
);
1501 if (k
> 1 && G_IS_DIR_SEPARATOR (g_tmp_dir
[k
- 1]))
1502 g_tmp_dir
[k
- 1] = '\0';
1508 g_tmp_dir
= g_strdup ("/tmp");
1510 #endif /* !G_OS_WIN32 */
1513 /* We check $HOME first for Win32, though it is a last resort for Unix
1514 * where we prefer the results of getpwuid().
1516 g_home_dir
= g_strdup (g_getenv ("HOME"));
1518 /* Only believe HOME if it is an absolute path and exists */
1521 if (!(g_path_is_absolute (g_home_dir
) &&
1522 g_file_test (g_home_dir
, G_FILE_TEST_IS_DIR
)))
1524 g_free (g_home_dir
);
1529 /* In case HOME is Unix-style (it happens), convert it to
1535 while ((p
= strchr (g_home_dir
, '/')) != NULL
)
1541 /* USERPROFILE is probably the closest equivalent to $HOME? */
1542 if (g_getenv ("USERPROFILE") != NULL
)
1543 g_home_dir
= g_strdup (g_getenv ("USERPROFILE"));
1547 g_home_dir
= get_special_folder (CSIDL_PROFILE
);
1550 g_home_dir
= get_windows_directory_root ();
1551 #endif /* G_OS_WIN32 */
1555 struct passwd
*pw
= NULL
;
1556 gpointer buffer
= NULL
;
1560 # if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
1562 # ifdef _SC_GETPW_R_SIZE_MAX
1563 /* This reurns the maximum length */
1564 glong bufsize
= sysconf (_SC_GETPW_R_SIZE_MAX
);
1568 # else /* _SC_GETPW_R_SIZE_MAX */
1570 # endif /* _SC_GETPW_R_SIZE_MAX */
1572 logname
= (gchar
*) g_getenv ("LOGNAME");
1577 /* we allocate 6 extra bytes to work around a bug in
1578 * Mac OS < 10.3. See #156446
1580 buffer
= g_malloc (bufsize
+ 6);
1583 # ifdef HAVE_POSIX_GETPWUID_R
1585 error
= getpwnam_r (logname
, &pwd
, buffer
, bufsize
, &pw
);
1586 if (!pw
|| (pw
->pw_uid
!= getuid ())) {
1587 /* LOGNAME is lying, fall back to looking up the uid */
1588 error
= getpwuid_r (getuid (), &pwd
, buffer
, bufsize
, &pw
);
1591 error
= getpwuid_r (getuid (), &pwd
, buffer
, bufsize
, &pw
);
1593 error
= error
< 0 ? errno
: error
;
1594 # else /* HAVE_NONPOSIX_GETPWUID_R */
1595 /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
1596 # if defined(_AIX) || defined(__hpux)
1597 error
= getpwuid_r (getuid (), &pwd
, buffer
, bufsize
);
1598 pw
= error
== 0 ? &pwd
: NULL
;
1601 pw
= getpwnam_r (logname
, &pwd
, buffer
, bufsize
);
1602 if (!pw
|| (pw
->pw_uid
!= getuid ())) {
1603 /* LOGNAME is lying, fall back to looking up the uid */
1604 pw
= getpwuid_r (getuid (), &pwd
, buffer
, bufsize
);
1607 pw
= getpwuid_r (getuid (), &pwd
, buffer
, bufsize
);
1609 error
= pw
? 0 : errno
;
1611 # endif /* HAVE_NONPOSIX_GETPWUID_R */
1615 /* we bail out prematurely if the user id can't be found
1616 * (should be pretty rare case actually), or if the buffer
1617 * should be sufficiently big and lookups are still not
1620 if (error
== 0 || error
== ENOENT
)
1622 g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
1623 (gulong
) getuid ());
1626 if (bufsize
> 32 * 1024)
1628 g_warning ("getpwuid_r(): failed due to: %s.",
1629 g_strerror (error
));
1637 # endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
1642 pw
= getpwuid (getuid ());
1647 g_user_name
= g_strdup (pw
->pw_name
);
1649 if (pw
->pw_gecos
&& *pw
->pw_gecos
!= '\0')
1651 gchar
**gecos_fields
;
1654 /* split the gecos field and substitute '&' */
1655 gecos_fields
= g_strsplit (pw
->pw_gecos
, ",", 0);
1656 name_parts
= g_strsplit (gecos_fields
[0], "&", 0);
1657 pw
->pw_name
[0] = g_ascii_toupper (pw
->pw_name
[0]);
1658 g_real_name
= g_strjoinv (pw
->pw_name
, name_parts
);
1659 g_strfreev (gecos_fields
);
1660 g_strfreev (name_parts
);
1664 g_home_dir
= g_strdup (pw
->pw_dir
);
1669 #else /* !HAVE_PWD_H */
1672 if (G_WIN32_HAVE_WIDECHAR_API ())
1674 guint len
= UNLEN
+1;
1675 wchar_t buffer
[UNLEN
+1];
1677 if (GetUserNameW (buffer
, (LPDWORD
) &len
))
1679 g_user_name
= g_utf16_to_utf8 (buffer
, -1, NULL
, NULL
, NULL
);
1680 g_real_name
= g_strdup (g_user_name
);
1685 guint len
= UNLEN
+1;
1686 char buffer
[UNLEN
+1];
1688 if (GetUserNameA (buffer
, (LPDWORD
) &len
))
1690 g_user_name
= g_locale_to_utf8 (buffer
, -1, NULL
, NULL
, NULL
);
1691 g_real_name
= g_strdup (g_user_name
);
1694 #endif /* G_OS_WIN32 */
1696 #endif /* !HAVE_PWD_H */
1700 g_home_dir
= g_strdup (g_getenv ("HOME"));
1704 /* change '\\' in %HOME% to '/' */
1705 g_strdelimit (g_home_dir
, "\\",'/');
1708 g_user_name
= g_strdup ("somebody");
1710 g_real_name
= g_strdup ("Unknown");
1714 gboolean hostname_fail
= (gethostname (hostname
, sizeof (hostname
)) == -1);
1716 DWORD size
= sizeof (hostname
);
1717 gboolean hostname_fail
= (!GetComputerName (hostname
, &size
));
1719 g_host_name
= g_strdup (hostname_fail
? "localhost" : hostname
);
1723 g_tmp_dir_cp
= g_locale_from_utf8 (g_tmp_dir
, -1, NULL
, NULL
, NULL
);
1724 g_user_name_cp
= g_locale_from_utf8 (g_user_name
, -1, NULL
, NULL
, NULL
);
1725 g_real_name_cp
= g_locale_from_utf8 (g_real_name
, -1, NULL
, NULL
, NULL
);
1728 g_tmp_dir_cp
= g_strdup ("\\");
1729 if (!g_user_name_cp
)
1730 g_user_name_cp
= g_strdup ("somebody");
1731 if (!g_real_name_cp
)
1732 g_real_name_cp
= g_strdup ("Unknown");
1734 /* home_dir might be NULL, unlike tmp_dir, user_name and
1738 g_home_dir_cp
= g_locale_from_utf8 (g_home_dir
, -1, NULL
, NULL
, NULL
);
1740 g_home_dir_cp
= NULL
;
1741 #endif /* G_OS_WIN32 */
1745 g_get_any_init (void)
1748 g_get_any_init_do ();
1752 g_get_any_init_locked (void)
1754 G_LOCK (g_utils_global
);
1756 G_UNLOCK (g_utils_global
);
1763 * Gets the user name of the current user. The encoding of the returned
1764 * string is system-defined. On UNIX, it might be the preferred file name
1765 * encoding, or something else, and there is no guarantee that it is even
1766 * consistent on a machine. On Windows, it is always UTF-8.
1768 * Returns: the user name of the current user.
1770 G_CONST_RETURN gchar
*
1771 g_get_user_name (void)
1773 g_get_any_init_locked ();
1780 * Gets the real name of the user. This usually comes from the user's entry
1781 * in the <filename>passwd</filename> file. The encoding of the returned
1782 * string is system-defined. (On Windows, it is, however, always UTF-8.)
1783 * If the real user name cannot be determined, the string "Unknown" is
1786 * Returns: the user's real name.
1788 G_CONST_RETURN gchar
*
1789 g_get_real_name (void)
1791 g_get_any_init_locked ();
1798 * Gets the current user's home directory.
1800 * Note that in contrast to traditional UNIX tools, this function
1801 * prefers <filename>passwd</filename> entries over the <envar>HOME</envar>
1802 * environment variable.
1804 * Returns: the current user's home directory.
1806 G_CONST_RETURN gchar
*
1807 g_get_home_dir (void)
1809 g_get_any_init_locked ();
1816 * Gets the directory to use for temporary files. This is found from
1817 * inspecting the environment variables <envar>TMPDIR</envar>,
1818 * <envar>TMP</envar>, and <envar>TEMP</envar> in that order. If none
1819 * of those are defined "/tmp" is returned on UNIX and "C:\" on Windows.
1820 * The encoding of the returned string is system-defined. On Windows,
1821 * it is always UTF-8. The return value is never %NULL.
1823 * Returns: the directory to use for temporary files.
1825 G_CONST_RETURN gchar
*
1826 g_get_tmp_dir (void)
1828 g_get_any_init_locked ();
1835 * Return a name for the machine.
1837 * The returned name is not necessarily a fully-qualified domain name,
1838 * or even present in DNS or some other name service at all. It need
1839 * not even be unique on your local network or site, but usually it
1840 * is. Callers should not rely on the return value having any specific
1841 * properties like uniqueness for security purposes. Even if the name
1842 * of the machine is changed while an application is running, the
1843 * return value from this function does not change. The returned
1844 * string is owned by GLib and should not be modified or freed. If no
1845 * name can be determined, a default fixed string "localhost" is
1848 * Returns: the host name of the machine.
1853 g_get_host_name (void)
1855 g_get_any_init_locked ();
1859 G_LOCK_DEFINE_STATIC (g_prgname
);
1860 static gchar
*g_prgname
= NULL
;
1865 * Gets the name of the program. This name should <emphasis>not</emphasis>
1866 * be localized, contrast with g_get_application_name().
1867 * (If you are using GDK or GTK+ the program name is set in gdk_init(),
1868 * which is called by gtk_init(). The program name is found by taking
1869 * the last component of <literal>argv[0]</literal>.)
1871 * Returns: the name of the program. The returned string belongs
1872 * to GLib and must not be modified or freed.
1875 g_get_prgname (void)
1881 if (g_prgname
== NULL
)
1883 static gboolean beenhere
= FALSE
;
1887 gchar
*utf8_buf
= NULL
;
1890 if (G_WIN32_HAVE_WIDECHAR_API ())
1892 wchar_t buf
[MAX_PATH
+1];
1893 if (GetModuleFileNameW (GetModuleHandle (NULL
),
1894 buf
, G_N_ELEMENTS (buf
)) > 0)
1895 utf8_buf
= g_utf16_to_utf8 (buf
, -1, NULL
, NULL
, NULL
);
1899 gchar buf
[MAX_PATH
+1];
1900 if (GetModuleFileNameA (GetModuleHandle (NULL
),
1901 buf
, G_N_ELEMENTS (buf
)) > 0)
1902 utf8_buf
= g_locale_to_utf8 (buf
, -1, NULL
, NULL
, NULL
);
1906 g_prgname
= g_path_get_basename (utf8_buf
);
1913 G_UNLOCK (g_prgname
);
1920 * @prgname: the name of the program.
1922 * Sets the name of the program. This name should <emphasis>not</emphasis>
1923 * be localized, contrast with g_set_application_name(). Note that for
1924 * thread-safety reasons this function can only be called once.
1927 g_set_prgname (const gchar
*prgname
)
1931 g_prgname
= g_strdup (prgname
);
1932 G_UNLOCK (g_prgname
);
1935 G_LOCK_DEFINE_STATIC (g_application_name
);
1936 static gchar
*g_application_name
= NULL
;
1939 * g_get_application_name:
1941 * Gets a human-readable name for the application, as set by
1942 * g_set_application_name(). This name should be localized if
1943 * possible, and is intended for display to the user. Contrast with
1944 * g_get_prgname(), which gets a non-localized name. If
1945 * g_set_application_name() has not been called, returns the result of
1946 * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
1949 * Return value: human-readable application name. may return %NULL
1953 G_CONST_RETURN gchar
*
1954 g_get_application_name (void)
1958 G_LOCK (g_application_name
);
1959 retval
= g_application_name
;
1960 G_UNLOCK (g_application_name
);
1963 return g_get_prgname ();
1969 * g_set_application_name:
1970 * @application_name: localized name of the application
1972 * Sets a human-readable name for the application. This name should be
1973 * localized if possible, and is intended for display to the user.
1974 * Contrast with g_set_prgname(), which sets a non-localized name.
1975 * g_set_prgname() will be called automatically by gtk_init(),
1976 * but g_set_application_name() will not.
1978 * Note that for thread safety reasons, this function can only
1981 * The application name will be used in contexts such as error messages,
1982 * or when displaying an application's name in the task list.
1986 g_set_application_name (const gchar
*application_name
)
1988 gboolean already_set
= FALSE
;
1990 G_LOCK (g_application_name
);
1991 if (g_application_name
)
1994 g_application_name
= g_strdup (application_name
);
1995 G_UNLOCK (g_application_name
);
1998 g_warning ("g_set_application() name called multiple times");
2002 * g_get_user_data_dir:
2004 * Returns a base directory in which to access application data such
2005 * as icons that is customized for a particular user.
2007 * On UNIX platforms this is determined using the mechanisms described in
2008 * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2009 * XDG Base Directory Specification</ulink>
2011 * Return value: a string owned by GLib that must not be modified
2015 G_CONST_RETURN gchar
*
2016 g_get_user_data_dir (void)
2020 G_LOCK (g_utils_global
);
2022 if (!g_user_data_dir
)
2025 data_dir
= get_special_folder (CSIDL_PERSONAL
);
2027 data_dir
= (gchar
*) g_getenv ("XDG_DATA_HOME");
2029 if (data_dir
&& data_dir
[0])
2030 data_dir
= g_strdup (data_dir
);
2032 if (!data_dir
|| !data_dir
[0])
2037 data_dir
= g_build_filename (g_home_dir
, ".local",
2040 data_dir
= g_build_filename (g_tmp_dir
, g_user_name
, ".local",
2044 g_user_data_dir
= data_dir
;
2047 data_dir
= g_user_data_dir
;
2049 G_UNLOCK (g_utils_global
);
2055 * g_get_user_config_dir:
2057 * Returns a base directory in which to store user-specific application
2058 * configuration information such as user preferences and settings.
2060 * On UNIX platforms this is determined using the mechanisms described in
2061 * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2062 * XDG Base Directory Specification</ulink>
2064 * Return value: a string owned by GLib that must not be modified
2068 G_CONST_RETURN gchar
*
2069 g_get_user_config_dir (void)
2073 G_LOCK (g_utils_global
);
2075 if (!g_user_config_dir
)
2078 config_dir
= get_special_folder (CSIDL_APPDATA
);
2080 config_dir
= (gchar
*) g_getenv ("XDG_CONFIG_HOME");
2082 if (config_dir
&& config_dir
[0])
2083 config_dir
= g_strdup (config_dir
);
2085 if (!config_dir
|| !config_dir
[0])
2090 config_dir
= g_build_filename (g_home_dir
, ".config", NULL
);
2092 config_dir
= g_build_filename (g_tmp_dir
, g_user_name
, ".config", NULL
);
2094 g_user_config_dir
= config_dir
;
2097 config_dir
= g_user_config_dir
;
2099 G_UNLOCK (g_utils_global
);
2105 * g_get_user_cache_dir:
2107 * Returns a base directory in which to store non-essential, cached
2108 * data specific to particular user.
2110 * On UNIX platforms this is determined using the mechanisms described in
2111 * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2112 * XDG Base Directory Specification</ulink>
2114 * Return value: a string owned by GLib that must not be modified
2118 G_CONST_RETURN gchar
*
2119 g_get_user_cache_dir (void)
2123 G_LOCK (g_utils_global
);
2125 if (!g_user_cache_dir
)
2128 cache_dir
= get_special_folder (CSIDL_INTERNET_CACHE
); /* XXX correct? */
2130 cache_dir
= (gchar
*) g_getenv ("XDG_CACHE_HOME");
2132 if (cache_dir
&& cache_dir
[0])
2133 cache_dir
= g_strdup (cache_dir
);
2135 if (!cache_dir
|| !cache_dir
[0])
2140 cache_dir
= g_build_filename (g_home_dir
, ".cache", NULL
);
2142 cache_dir
= g_build_filename (g_tmp_dir
, g_user_name
, ".cache", NULL
);
2144 g_user_cache_dir
= cache_dir
;
2147 cache_dir
= g_user_cache_dir
;
2149 G_UNLOCK (g_utils_global
);
2156 #undef g_get_system_data_dirs
2159 get_module_for_address (gconstpointer address
)
2161 /* Holds the g_utils_global lock */
2163 static gboolean beenhere
= FALSE
;
2164 typedef BOOL (WINAPI
*t_GetModuleHandleExA
) (DWORD
, LPCTSTR
, HMODULE
*);
2165 static t_GetModuleHandleExA p_GetModuleHandleExA
= NULL
;
2173 p_GetModuleHandleExA
=
2174 (t_GetModuleHandleExA
) GetProcAddress (LoadLibrary ("kernel32.dll"),
2175 "GetModuleHandleExA");
2179 if (p_GetModuleHandleExA
== NULL
||
2180 !(*p_GetModuleHandleExA
) (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT
|
2181 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
2184 MEMORY_BASIC_INFORMATION mbi
;
2185 VirtualQuery (address
, &mbi
, sizeof (mbi
));
2186 hmodule
= (HMODULE
) mbi
.AllocationBase
;
2193 get_module_share_dir (gconstpointer address
)
2196 gchar
*filename
= NULL
;
2199 hmodule
= get_module_for_address (address
);
2200 if (hmodule
== NULL
)
2203 if (G_WIN32_IS_NT_BASED ())
2205 wchar_t wfilename
[MAX_PATH
];
2206 if (GetModuleFileNameW (hmodule
, wfilename
, G_N_ELEMENTS (wfilename
)))
2207 filename
= g_utf16_to_utf8 (wfilename
, -1, NULL
, NULL
, NULL
);
2211 char cpfilename
[MAX_PATH
];
2212 if (GetModuleFileNameA (hmodule
, cpfilename
, G_N_ELEMENTS (cpfilename
)))
2213 filename
= g_locale_to_utf8 (cpfilename
, -1, NULL
, NULL
, NULL
);
2216 if (filename
== NULL
)
2219 if ((p
= strrchr (filename
, G_DIR_SEPARATOR
)) != NULL
)
2222 p
= strrchr (filename
, G_DIR_SEPARATOR
);
2223 if (p
&& (g_ascii_strcasecmp (p
+ 1, "bin") == 0))
2226 retval
= g_build_filename (filename
, "share", NULL
);
2232 G_CONST_RETURN gchar
* G_CONST_RETURN
*
2233 g_win32_get_system_data_dirs_for_module (gconstpointer address
)
2237 static GHashTable
*per_module_data_dirs
= NULL
;
2243 G_LOCK (g_utils_global
);
2244 hmodule
= get_module_for_address (address
);
2245 if (hmodule
!= NULL
)
2247 if (per_module_data_dirs
== NULL
)
2248 per_module_data_dirs
= g_hash_table_new (NULL
, NULL
);
2251 retval
= g_hash_table_lookup (per_module_data_dirs
, hmodule
);
2255 G_UNLOCK (g_utils_global
);
2256 return (G_CONST_RETURN gchar
* G_CONST_RETURN
*) retval
;
2262 data_dirs
= g_array_new (TRUE
, TRUE
, sizeof (char *));
2264 /* Documents and Settings\All Users\Application Data */
2265 p
= get_special_folder (CSIDL_COMMON_APPDATA
);
2267 g_array_append_val (data_dirs
, p
);
2269 /* Documents and Settings\All Users\Documents */
2270 p
= get_special_folder (CSIDL_COMMON_DOCUMENTS
);
2272 g_array_append_val (data_dirs
, p
);
2274 /* Using the above subfolders of Documents and Settings perhaps
2275 * makes sense from a Windows perspective.
2277 * But looking at the actual use cases of this function in GTK+
2278 * and GNOME software, what we really want is the "share"
2279 * subdirectory of the installation directory for the package
2280 * our caller is a part of.
2282 * The address parameter, if non-NULL, points to a function in the
2283 * calling module. Use that to determine that module's installation
2284 * folder, and use its "share" subfolder.
2286 * Additionally, also use the "share" subfolder of the installation
2287 * locations of GLib and the .exe file being run.
2289 * To guard against none of the above being what is really wanted,
2290 * callers of this function should have Win32-specific code to look
2291 * up their installation folder themselves, and handle a subfolder
2292 * "share" of it in the same way as the folders returned from this
2296 p
= get_module_share_dir (address
);
2298 g_array_append_val (data_dirs
, p
);
2300 p
= g_win32_get_package_installation_subdirectory (NULL
, dll_name
, "share");
2302 g_array_append_val (data_dirs
, p
);
2304 p
= g_win32_get_package_installation_subdirectory (NULL
, NULL
, "share");
2306 g_array_append_val (data_dirs
, p
);
2308 retval
= (gchar
**) g_array_free (data_dirs
, FALSE
);
2312 if (hmodule
!= NULL
)
2313 g_hash_table_insert (per_module_data_dirs
, hmodule
, retval
);
2314 G_UNLOCK (g_utils_global
);
2317 return (G_CONST_RETURN gchar
* G_CONST_RETURN
*) retval
;
2323 * g_get_system_data_dirs:
2325 * Returns an ordered list of base directories in which to access
2326 * system-wide application data.
2328 * On UNIX platforms this is determined using the mechanisms described in
2329 * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2330 * XDG Base Directory Specification</ulink>
2332 * On Windows the first elements in the list are the Application Data
2333 * and Documents folders for All Users. (These can be determined only
2334 * on Windows 2000 or later and are not present in the list on other
2335 * Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
2336 * CSIDL_COMMON_DOCUMENTS.
2338 * Then follows the "share" subfolder in the installation folder for
2339 * the package containing the DLL that calls this function, if it can
2342 * Finally the list contains the "share" subfolder in the installation
2343 * folder for GLib, and in the installation folder for the package the
2344 * application's .exe file belongs to.
2346 * The installation folders above are determined by looking up the
2347 * folder where the module (DLL or EXE) in question is located. If the
2348 * folder's name is "bin", its parent is used, otherwise the folder
2351 * Note that on Windows the returned list can vary depending on where
2352 * this function is called.
2354 * Return value: a %NULL-terminated array of strings owned by GLib that must
2355 * not be modified or freed.
2358 G_CONST_RETURN gchar
* G_CONST_RETURN
*
2359 g_get_system_data_dirs (void)
2361 gchar
**data_dir_vector
;
2363 G_LOCK (g_utils_global
);
2365 if (!g_system_data_dirs
)
2368 data_dir_vector
= (gchar
**) g_win32_get_system_data_dirs_for_module (NULL
);
2370 gchar
*data_dirs
= (gchar
*) g_getenv ("XDG_DATA_DIRS");
2372 if (!data_dirs
|| !data_dirs
[0])
2373 data_dirs
= "/usr/local/share/:/usr/share/";
2375 data_dir_vector
= g_strsplit (data_dirs
, G_SEARCHPATH_SEPARATOR_S
, 0);
2378 g_system_data_dirs
= data_dir_vector
;
2381 data_dir_vector
= g_system_data_dirs
;
2383 G_UNLOCK (g_utils_global
);
2385 return (G_CONST_RETURN gchar
* G_CONST_RETURN
*) data_dir_vector
;
2389 * g_get_system_config_dirs:
2391 * Returns an ordered list of base directories in which to access
2392 * system-wide configuration information.
2394 * On UNIX platforms this is determined using the mechanisms described in
2395 * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2396 * XDG Base Directory Specification</ulink>
2398 * Return value: a %NULL-terminated array of strings owned by GLib that must
2399 * not be modified or freed.
2402 G_CONST_RETURN gchar
* G_CONST_RETURN
*
2403 g_get_system_config_dirs (void)
2405 gchar
*conf_dirs
, **conf_dir_vector
;
2407 G_LOCK (g_utils_global
);
2409 if (!g_system_config_dirs
)
2412 conf_dirs
= get_special_folder (CSIDL_COMMON_APPDATA
);
2415 conf_dir_vector
= g_strsplit (conf_dirs
, G_SEARCHPATH_SEPARATOR_S
, 0);
2420 /* Return empty list */
2421 conf_dir_vector
= g_strsplit ("", G_SEARCHPATH_SEPARATOR_S
, 0);
2424 conf_dirs
= (gchar
*) g_getenv ("XDG_CONFIG_DIRS");
2426 if (!conf_dirs
|| !conf_dirs
[0])
2427 conf_dirs
= "/etc/xdg";
2429 conf_dir_vector
= g_strsplit (conf_dirs
, G_SEARCHPATH_SEPARATOR_S
, 0);
2432 g_system_config_dirs
= conf_dir_vector
;
2435 conf_dir_vector
= g_system_config_dirs
;
2436 G_UNLOCK (g_utils_global
);
2438 return (G_CONST_RETURN gchar
* G_CONST_RETURN
*) conf_dir_vector
;
2443 static GHashTable
*alias_table
= NULL
;
2445 /* read an alias file for the locales */
2447 read_aliases (gchar
*file
)
2453 alias_table
= g_hash_table_new (g_str_hash
, g_str_equal
);
2454 fp
= fopen (file
,"r");
2457 while (fgets (buf
, 256, fp
))
2463 /* Line is a comment */
2464 if ((buf
[0] == '#') || (buf
[0] == '\0'))
2467 /* Reads first column */
2468 for (p
= buf
, q
= NULL
; *p
; p
++) {
2469 if ((*p
== '\t') || (*p
== ' ') || (*p
== ':')) {
2472 while ((*q
== '\t') || (*q
== ' ')) {
2478 /* The line only had one column */
2479 if (!q
|| *q
== '\0')
2482 /* Read second column */
2483 for (p
= q
; *p
; p
++) {
2484 if ((*p
== '\t') || (*p
== ' ')) {
2490 /* Add to alias table if necessary */
2491 if (!g_hash_table_lookup (alias_table
, buf
)) {
2492 g_hash_table_insert (alias_table
, g_strdup (buf
), g_strdup (q
));
2501 unalias_lang (char *lang
)
2508 read_aliases ("/usr/share/locale/locale.alias");
2511 while ((p
= g_hash_table_lookup (alias_table
, lang
)) && (strcmp (p
, lang
) != 0))
2516 static gboolean said_before
= FALSE
;
2518 g_warning ("Too many alias levels for a locale, "
2519 "may indicate a loop");
2528 /* Mask for components of locale spec. The ordering here is from
2529 * least significant to most significant
2533 COMPONENT_CODESET
= 1 << 0,
2534 COMPONENT_TERRITORY
= 1 << 1,
2535 COMPONENT_MODIFIER
= 1 << 2
2538 /* Break an X/Open style locale specification into components
2541 explode_locale (const gchar
*locale
,
2547 const gchar
*uscore_pos
;
2548 const gchar
*at_pos
;
2549 const gchar
*dot_pos
;
2553 uscore_pos
= strchr (locale
, '_');
2554 dot_pos
= strchr (uscore_pos
? uscore_pos
: locale
, '.');
2555 at_pos
= strchr (dot_pos
? dot_pos
: (uscore_pos
? uscore_pos
: locale
), '@');
2559 mask
|= COMPONENT_MODIFIER
;
2560 *modifier
= g_strdup (at_pos
);
2563 at_pos
= locale
+ strlen (locale
);
2567 mask
|= COMPONENT_CODESET
;
2568 *codeset
= g_strndup (dot_pos
, at_pos
- dot_pos
);
2575 mask
|= COMPONENT_TERRITORY
;
2576 *territory
= g_strndup (uscore_pos
, dot_pos
- uscore_pos
);
2579 uscore_pos
= dot_pos
;
2581 *language
= g_strndup (locale
, uscore_pos
- locale
);
2587 * Compute all interesting variants for a given locale name -
2588 * by stripping off different components of the value.
2590 * For simplicity, we assume that the locale is in
2591 * X/Open format: language[_territory][.codeset][@modifier]
2593 * TODO: Extend this to handle the CEN format (see the GNUlibc docs)
2594 * as well. We could just copy the code from glibc wholesale
2595 * but it is big, ugly, and complicated, so I'm reluctant
2596 * to do so when this should handle 99% of the time...
2599 _g_compute_locale_variants (const gchar
*locale
)
2601 GSList
*retval
= NULL
;
2603 gchar
*language
= NULL
;
2604 gchar
*territory
= NULL
;
2605 gchar
*codeset
= NULL
;
2606 gchar
*modifier
= NULL
;
2611 g_return_val_if_fail (locale
!= NULL
, NULL
);
2613 mask
= explode_locale (locale
, &language
, &territory
, &codeset
, &modifier
);
2615 /* Iterate through all possible combinations, from least attractive
2616 * to most attractive.
2618 for (i
= 0; i
<= mask
; i
++)
2619 if ((i
& ~mask
) == 0)
2621 gchar
*val
= g_strconcat (language
,
2622 (i
& COMPONENT_TERRITORY
) ? territory
: "",
2623 (i
& COMPONENT_CODESET
) ? codeset
: "",
2624 (i
& COMPONENT_MODIFIER
) ? modifier
: "",
2626 retval
= g_slist_prepend (retval
, val
);
2630 if (mask
& COMPONENT_CODESET
)
2632 if (mask
& COMPONENT_TERRITORY
)
2634 if (mask
& COMPONENT_MODIFIER
)
2640 /* The following is (partly) taken from the gettext package.
2641 Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc. */
2643 static const gchar
*
2644 guess_category_value (const gchar
*category_name
)
2646 const gchar
*retval
;
2648 /* The highest priority value is the `LANGUAGE' environment
2649 variable. This is a GNU extension. */
2650 retval
= g_getenv ("LANGUAGE");
2651 if ((retval
!= NULL
) && (retval
[0] != '\0'))
2654 /* `LANGUAGE' is not set. So we have to proceed with the POSIX
2655 methods of looking to `LC_ALL', `LC_xxx', and `LANG'. On some
2656 systems this can be done by the `setlocale' function itself. */
2658 /* Setting of LC_ALL overwrites all other. */
2659 retval
= g_getenv ("LC_ALL");
2660 if ((retval
!= NULL
) && (retval
[0] != '\0'))
2663 /* Next comes the name of the desired category. */
2664 retval
= g_getenv (category_name
);
2665 if ((retval
!= NULL
) && (retval
[0] != '\0'))
2668 /* Last possibility is the LANG environment variable. */
2669 retval
= g_getenv ("LANG");
2670 if ((retval
!= NULL
) && (retval
[0] != '\0'))
2673 #ifdef G_PLATFORM_WIN32
2674 /* g_win32_getlocale() first checks for LC_ALL, LC_MESSAGES and
2675 * LANG, which we already did above. Oh well. The main point of
2676 * calling g_win32_getlocale() is to get the thread's locale as used
2677 * by Windows and the Microsoft C runtime (in the "English_United
2678 * States" format) translated into the Unixish format.
2680 retval
= g_win32_getlocale ();
2681 if ((retval
!= NULL
) && (retval
[0] != '\0'))
2688 typedef struct _GLanguageNamesCache GLanguageNamesCache
;
2690 struct _GLanguageNamesCache
{
2692 gchar
**language_names
;
2696 language_names_cache_free (gpointer data
)
2698 GLanguageNamesCache
*cache
= data
;
2699 g_free (cache
->languages
);
2700 g_strfreev (cache
->language_names
);
2705 * g_get_language_names:
2707 * Computes a list of applicable locale names, which can be used to
2708 * e.g. construct locale-dependent filenames or search paths. The returned
2709 * list is sorted from most desirable to least desirable and always contains
2710 * the default locale "C".
2712 * For example, if LANGUAGE=de:en_US, then the returned list is
2713 * "de", "en_US", "en", "C".
2715 * This function consults the environment variables <envar>LANGUAGE</envar>,
2716 * <envar>LC_ALL</envar>, <envar>LC_MESSAGES</envar> and <envar>LANG</envar>
2717 * to find the list of locales specified by the user.
2719 * Return value: a %NULL-terminated array of strings owned by GLib
2720 * that must not be modified or freed.
2724 G_CONST_RETURN gchar
* G_CONST_RETURN
*
2725 g_get_language_names (void)
2727 static GStaticPrivate cache_private
= G_STATIC_PRIVATE_INIT
;
2728 GLanguageNamesCache
*cache
= g_static_private_get (&cache_private
);
2733 cache
= g_new0 (GLanguageNamesCache
, 1);
2734 g_static_private_set (&cache_private
, cache
, language_names_cache_free
);
2737 value
= guess_category_value ("LC_MESSAGES");
2741 if (!(cache
->languages
&& strcmp (cache
->languages
, value
) == 0))
2748 g_free (cache
->languages
);
2749 g_strfreev (cache
->language_names
);
2750 cache
->languages
= g_strdup (value
);
2752 alist
= g_strsplit (value
, ":", 0);
2754 for (a
= alist
; *a
; a
++)
2756 gchar
*b
= unalias_lang (*a
);
2757 list
= g_slist_concat (list
, _g_compute_locale_variants (b
));
2760 list
= g_slist_append (list
, g_strdup ("C"));
2762 cache
->language_names
= languages
= g_new (gchar
*, g_slist_length (list
) + 1);
2763 for (l
= list
, i
= 0; l
; l
= l
->next
, i
++)
2764 languages
[i
] = l
->data
;
2765 languages
[i
] = NULL
;
2767 g_slist_free (list
);
2770 return (G_CONST_RETURN gchar
* G_CONST_RETURN
*) cache
->language_names
;
2775 * @v: a #gpointer key
2777 * Converts a gpointer to a hash value.
2778 * It can be passed to g_hash_table_new() as the @hash_func parameter,
2779 * when using pointers as keys in a #GHashTable.
2781 * Returns: a hash value corresponding to the key.
2784 g_direct_hash (gconstpointer v
)
2786 return GPOINTER_TO_UINT (v
);
2792 * @v2: a key to compare with @v1.
2794 * Compares two #gpointer arguments and returns %TRUE if they are equal.
2795 * It can be passed to g_hash_table_new() as the @key_equal_func
2796 * parameter, when using pointers as keys in a #GHashTable.
2798 * Returns: %TRUE if the two keys match.
2801 g_direct_equal (gconstpointer v1
,
2809 * @v1: a pointer to a #gint key.
2810 * @v2: a pointer to a #gint key to compare with @v1.
2812 * Compares the two #gint values being pointed to and returns
2813 * %TRUE if they are equal.
2814 * It can be passed to g_hash_table_new() as the @key_equal_func
2815 * parameter, when using pointers to integers as keys in a #GHashTable.
2817 * Returns: %TRUE if the two keys match.
2820 g_int_equal (gconstpointer v1
,
2823 return *((const gint
*) v1
) == *((const gint
*) v2
);
2828 * @v: a pointer to a #gint key
2830 * Converts a pointer to a #gint to a hash value.
2831 * It can be passed to g_hash_table_new() as the @hash_func parameter,
2832 * when using pointers to integers values as keys in a #GHashTable.
2834 * Returns: a hash value corresponding to the key.
2837 g_int_hash (gconstpointer v
)
2839 return *(const gint
*) v
;
2843 * g_nullify_pointer:
2844 * @nullify_location: the memory address of the pointer.
2846 * Set the pointer at the specified location to %NULL.
2849 g_nullify_pointer (gpointer
*nullify_location
)
2851 g_return_if_fail (nullify_location
!= NULL
);
2853 *nullify_location
= NULL
;
2859 * Get the codeset for the current locale.
2861 * Return value: a newly allocated string containing the name
2862 * of the codeset. This string must be freed with g_free().
2865 g_get_codeset (void)
2867 const gchar
*charset
;
2869 g_get_charset (&charset
);
2871 return g_strdup (charset
);
2874 /* This is called from g_thread_init(). It's used to
2875 * initialize some static data in a threadsafe way.
2878 _g_utils_thread_init (void)
2880 g_get_language_names ();
2885 #include <libintl.h>
2890 * _glib_get_locale_dir:
2892 * Return the path to the lib\locale subfolder of the GLib
2893 * installation folder. The path is in the system codepage. We have to
2894 * use system codepage as bindtextdomain() doesn't have a UTF-8
2897 static const gchar
*
2898 _glib_get_locale_dir (void)
2900 gchar
*dir
, *cp_dir
;
2901 gchar
*retval
= NULL
;
2903 dir
= g_win32_get_package_installation_directory (GETTEXT_PACKAGE
, dll_name
);
2904 cp_dir
= g_win32_locale_filename_from_utf8 (dir
);
2909 /* Don't use g_build_filename() on pathnames in the system
2910 * codepage. In CJK locales cp_dir might end with a double-byte
2911 * character whose trailing byte is a backslash.
2913 retval
= g_strconcat (cp_dir
, "\\lib\\locale", NULL
);
2920 return g_strdup ("");
2923 #undef GLIB_LOCALE_DIR
2924 #define GLIB_LOCALE_DIR _glib_get_locale_dir ()
2926 #endif /* G_OS_WIN32 */
2928 G_CONST_RETURN gchar
*
2929 _glib_gettext (const gchar
*str
)
2931 static gboolean _glib_gettext_initialized
= FALSE
;
2933 if (!_glib_gettext_initialized
)
2935 bindtextdomain(GETTEXT_PACKAGE
, GLIB_LOCALE_DIR
);
2936 # ifdef HAVE_BIND_TEXTDOMAIN_CODESET
2937 bind_textdomain_codeset (GETTEXT_PACKAGE
, "UTF-8");
2939 _glib_gettext_initialized
= TRUE
;
2942 return dgettext (GETTEXT_PACKAGE
, str
);
2945 #endif /* ENABLE_NLS */
2949 /* Binary compatibility versions. Not for newly compiled code. */
2951 #undef g_find_program_in_path
2954 g_find_program_in_path (const gchar
*program
)
2956 gchar
*utf8_program
= g_locale_to_utf8 (program
, -1, NULL
, NULL
, NULL
);
2957 gchar
*utf8_retval
= g_find_program_in_path_utf8 (utf8_program
);
2960 g_free (utf8_program
);
2961 if (utf8_retval
== NULL
)
2963 retval
= g_locale_from_utf8 (utf8_retval
, -1, NULL
, NULL
, NULL
);
2964 g_free (utf8_retval
);
2969 #undef g_get_current_dir
2972 g_get_current_dir (void)
2974 gchar
*utf8_dir
= g_get_current_dir_utf8 ();
2975 gchar
*dir
= g_locale_from_utf8 (utf8_dir
, -1, NULL
, NULL
, NULL
);
2982 G_CONST_RETURN gchar
*
2983 g_getenv (const gchar
*variable
)
2985 gchar
*utf8_variable
= g_locale_to_utf8 (variable
, -1, NULL
, NULL
, NULL
);
2986 const gchar
*utf8_value
= g_getenv_utf8 (utf8_variable
);
2990 g_free (utf8_variable
);
2993 value
= g_locale_from_utf8 (utf8_value
, -1, NULL
, NULL
, NULL
);
2994 quark
= g_quark_from_string (value
);
2997 return g_quark_to_string (quark
);
3003 g_setenv (const gchar
*variable
,
3007 gchar
*utf8_variable
= g_locale_to_utf8 (variable
, -1, NULL
, NULL
, NULL
);
3008 gchar
*utf8_value
= g_locale_to_utf8 (value
, -1, NULL
, NULL
, NULL
);
3009 gboolean retval
= g_setenv_utf8 (utf8_variable
, utf8_value
, overwrite
);
3011 g_free (utf8_variable
);
3012 g_free (utf8_value
);
3020 g_unsetenv (const gchar
*variable
)
3022 gchar
*utf8_variable
= g_locale_to_utf8 (variable
, -1, NULL
, NULL
, NULL
);
3024 g_unsetenv_utf8 (utf8_variable
);
3026 g_free (utf8_variable
);
3029 #undef g_get_user_name
3031 G_CONST_RETURN gchar
*
3032 g_get_user_name (void)
3034 g_get_any_init_locked ();
3035 return g_user_name_cp
;
3038 #undef g_get_real_name
3040 G_CONST_RETURN gchar
*
3041 g_get_real_name (void)
3043 g_get_any_init_locked ();
3044 return g_real_name_cp
;
3047 #undef g_get_home_dir
3049 G_CONST_RETURN gchar
*
3050 g_get_home_dir (void)
3052 g_get_any_init_locked ();
3053 return g_home_dir_cp
;
3056 #undef g_get_tmp_dir
3058 G_CONST_RETURN gchar
*
3059 g_get_tmp_dir (void)
3061 g_get_any_init_locked ();
3062 return g_tmp_dir_cp
;
3067 #define __G_UTILS_C__
3068 #include "galiasdef.c"