[docs] Improve the g_get_user_config_dir() docs a bit
[platform/upstream/glib.git] / glib / gutils.c
1 /* GLIB - Library of useful routines for C programming
2  * Copyright (C) 1995-1998  Peter Mattis, Spencer Kimball and Josh MacDonald
3  *
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.
8  *
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.
13  *
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.
18  */
19
20 /*
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/. 
25  */
26
27 /* 
28  * MT safe for the unix part, FIXME: make the win32 part MT safe as well.
29  */
30
31 #include "config.h"
32
33 #ifdef HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 #include <stdarg.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <locale.h>
40 #include <string.h>
41 #include <ctype.h>              /* For tolower() */
42 #include <errno.h>
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #ifdef HAVE_PWD_H
46 #include <pwd.h>
47 #endif
48 #include <sys/types.h>
49 #ifdef HAVE_SYS_PARAM_H
50 #include <sys/param.h>
51 #endif
52 #ifdef HAVE_CRT_EXTERNS_H 
53 #include <crt_externs.h> /* for _NSGetEnviron */
54 #endif
55
56 /* implement gutils's inline functions
57  */
58 #define G_IMPLEMENT_INLINES 1
59 #define __G_UTILS_C__
60 #include "glib.h"
61 #include "gprintfint.h"
62 #include "gthreadprivate.h"
63 #include "glibintl.h"
64 #include "galias.h"
65
66 #ifdef  MAXPATHLEN
67 #define G_PATH_LENGTH   MAXPATHLEN
68 #elif   defined (PATH_MAX)
69 #define G_PATH_LENGTH   PATH_MAX
70 #elif   defined (_PC_PATH_MAX)
71 #define G_PATH_LENGTH   sysconf(_PC_PATH_MAX)
72 #else   
73 #define G_PATH_LENGTH   2048
74 #endif
75
76 #ifdef G_PLATFORM_WIN32
77 #  define STRICT                /* Strict typing, please */
78 #  include <windows.h>
79 #  undef STRICT
80 #  ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
81 #    define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2
82 #    define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4
83 #  endif
84 #  include <lmcons.h>           /* For UNLEN */
85 #endif /* G_PLATFORM_WIN32 */
86
87 #ifdef G_OS_WIN32
88 #  include <direct.h>
89 #  include <shlobj.h>
90    /* older SDK (e.g. msvc 5.0) does not have these*/
91 #  ifndef CSIDL_MYMUSIC
92 #    define CSIDL_MYMUSIC 13
93 #  endif
94 #  ifndef CSIDL_MYVIDEO
95 #    define CSIDL_MYVIDEO 14
96 #  endif
97 #  ifndef CSIDL_INTERNET_CACHE
98 #    define CSIDL_INTERNET_CACHE 32
99 #  endif
100 #  ifndef CSIDL_COMMON_APPDATA
101 #    define CSIDL_COMMON_APPDATA 35
102 #  endif
103 #  ifndef CSIDL_MYPICTURES
104 #    define CSIDL_MYPICTURES 0x27
105 #  endif
106 #  ifndef CSIDL_COMMON_DOCUMENTS
107 #    define CSIDL_COMMON_DOCUMENTS 46
108 #  endif
109 #  ifndef CSIDL_PROFILE
110 #    define CSIDL_PROFILE 40
111 #  endif
112 #  include <process.h>
113 #endif
114
115 #ifdef HAVE_CARBON
116 #include <CoreServices/CoreServices.h>
117 #endif
118
119 #ifdef HAVE_CODESET
120 #include <langinfo.h>
121 #endif
122
123 const guint glib_major_version = GLIB_MAJOR_VERSION;
124 const guint glib_minor_version = GLIB_MINOR_VERSION;
125 const guint glib_micro_version = GLIB_MICRO_VERSION;
126 const guint glib_interface_age = GLIB_INTERFACE_AGE;
127 const guint glib_binary_age = GLIB_BINARY_AGE;
128
129 #ifdef G_PLATFORM_WIN32
130
131 static HMODULE glib_dll = NULL;
132
133 #ifdef DLL_EXPORT
134
135 BOOL WINAPI
136 DllMain (HINSTANCE hinstDLL,
137          DWORD     fdwReason,
138          LPVOID    lpvReserved)
139 {
140   if (fdwReason == DLL_PROCESS_ATTACH)
141       glib_dll = hinstDLL;
142
143   return TRUE;
144 }
145
146 #endif
147
148 gchar *
149 _glib_get_dll_directory (void)
150 {
151   gchar *retval;
152   gchar *p;
153   wchar_t wc_fn[MAX_PATH];
154
155 #ifdef DLL_EXPORT
156   if (glib_dll == NULL)
157     return NULL;
158 #endif
159
160   /* This code is different from that in
161    * g_win32_get_package_installation_directory_of_module() in that
162    * here we return the actual folder where the GLib DLL is. We don't
163    * do the check for it being in a "bin" or "lib" subfolder and then
164    * returning the parent of that.
165    *
166    * In a statically built GLib, glib_dll will be NULL and we will
167    * thus look up the application's .exe file's location.
168    */
169   if (!GetModuleFileNameW (glib_dll, wc_fn, MAX_PATH))
170     return NULL;
171
172   retval = g_utf16_to_utf8 (wc_fn, -1, NULL, NULL, NULL);
173
174   p = strrchr (retval, G_DIR_SEPARATOR);
175   if (p == NULL)
176     {
177       /* Wtf? */
178       return NULL;
179     }
180   *p = '\0';
181
182   return retval;
183 }
184
185 #endif
186
187 /**
188  * glib_check_version:
189  * @required_major: the required major version.
190  * @required_minor: the required minor version.
191  * @required_micro: the required micro version.
192  *
193  * Checks that the GLib library in use is compatible with the
194  * given version. Generally you would pass in the constants
195  * #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION
196  * as the three arguments to this function; that produces
197  * a check that the library in use is compatible with
198  * the version of GLib the application or module was compiled
199  * against.
200  *
201  * Compatibility is defined by two things: first the version
202  * of the running library is newer than the version
203  * @required_major.required_minor.@required_micro. Second
204  * the running library must be binary compatible with the
205  * version @required_major.required_minor.@required_micro
206  * (same major version.)
207  *
208  * Return value: %NULL if the GLib library is compatible with the
209  *   given version, or a string describing the version mismatch.
210  *   The returned string is owned by GLib and must not be modified
211  *   or freed.
212  *
213  * Since: 2.6
214  **/
215 const gchar *
216 glib_check_version (guint required_major,
217                     guint required_minor,
218                     guint required_micro)
219 {
220   gint glib_effective_micro = 100 * GLIB_MINOR_VERSION + GLIB_MICRO_VERSION;
221   gint required_effective_micro = 100 * required_minor + required_micro;
222
223   if (required_major > GLIB_MAJOR_VERSION)
224     return "GLib version too old (major mismatch)";
225   if (required_major < GLIB_MAJOR_VERSION)
226     return "GLib version too new (major mismatch)";
227   if (required_effective_micro < glib_effective_micro - GLIB_BINARY_AGE)
228     return "GLib version too new (micro mismatch)";
229   if (required_effective_micro > glib_effective_micro)
230     return "GLib version too old (micro mismatch)";
231   return NULL;
232 }
233
234 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
235 /**
236  * g_memmove: 
237  * @dest: the destination address to copy the bytes to.
238  * @src: the source address to copy the bytes from.
239  * @len: the number of bytes to copy.
240  *
241  * Copies a block of memory @len bytes long, from @src to @dest.
242  * The source and destination areas may overlap.
243  *
244  * In order to use this function, you must include 
245  * <filename>string.h</filename> yourself, because this macro will 
246  * typically simply resolve to memmove() and GLib does not include 
247  * <filename>string.h</filename> for you.
248  */
249 void 
250 g_memmove (gpointer      dest, 
251            gconstpointer src, 
252            gulong        len)
253 {
254   gchar* destptr = dest;
255   const gchar* srcptr = src;
256   if (src + len < dest || dest + len < src)
257     {
258       bcopy (src, dest, len);
259       return;
260     }
261   else if (dest <= src)
262     {
263       while (len--)
264         *(destptr++) = *(srcptr++);
265     }
266   else
267     {
268       destptr += len;
269       srcptr += len;
270       while (len--)
271         *(--destptr) = *(--srcptr);
272     }
273 }
274 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
275
276 #ifdef G_OS_WIN32
277 #undef g_atexit
278 #endif
279
280 /**
281  * g_atexit:
282  * @func: the function to call on normal program termination.
283  * 
284  * Specifies a function to be called at normal program termination.
285  *
286  * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
287  * macro that maps to a call to the atexit() function in the C
288  * library. This means that in case the code that calls g_atexit(),
289  * i.e. atexit(), is in a DLL, the function will be called when the
290  * DLL is detached from the program. This typically makes more sense
291  * than that the function is called when the GLib DLL is detached,
292  * which happened earlier when g_atexit() was a function in the GLib
293  * DLL.
294  *
295  * The behaviour of atexit() in the context of dynamically loaded
296  * modules is not formally specified and varies wildly.
297  *
298  * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
299  * loaded module which is unloaded before the program terminates might
300  * well cause a crash at program exit.
301  *
302  * Some POSIX systems implement atexit() like Windows, and have each
303  * dynamically loaded module maintain an own atexit chain that is
304  * called when the module is unloaded.
305  *
306  * On other POSIX systems, before a dynamically loaded module is
307  * unloaded, the registered atexit functions (if any) residing in that
308  * module are called, regardless where the code that registered them
309  * resided. This is presumably the most robust approach.
310  *
311  * As can be seen from the above, for portability it's best to avoid
312  * calling g_atexit() (or atexit()) except in the main executable of a
313  * program.
314  */
315 void
316 g_atexit (GVoidFunc func)
317 {
318   gint result;
319   const gchar *error = NULL;
320
321   /* keep this in sync with glib.h */
322
323 #ifdef  G_NATIVE_ATEXIT
324   result = ATEXIT (func);
325   if (result)
326     error = g_strerror (errno);
327 #elif defined (HAVE_ATEXIT)
328 #  ifdef NeXT /* @#%@! NeXTStep */
329   result = !atexit ((void (*)(void)) func);
330   if (result)
331     error = g_strerror (errno);
332 #  else
333   result = atexit ((void (*)(void)) func);
334   if (result)
335     error = g_strerror (errno);
336 #  endif /* NeXT */
337 #elif defined (HAVE_ON_EXIT)
338   result = on_exit ((void (*)(int, void *)) func, NULL);
339   if (result)
340     error = g_strerror (errno);
341 #else
342   result = 0;
343   error = "no implementation";
344 #endif /* G_NATIVE_ATEXIT */
345
346   if (error)
347     g_error ("Could not register atexit() function: %s", error);
348 }
349
350 /* Based on execvp() from GNU Libc.
351  * Some of this code is cut-and-pasted into gspawn.c
352  */
353
354 static gchar*
355 my_strchrnul (const gchar *str, 
356               gchar        c)
357 {
358   gchar *p = (gchar*)str;
359   while (*p && (*p != c))
360     ++p;
361
362   return p;
363 }
364
365 #ifdef G_OS_WIN32
366
367 static gchar *inner_find_program_in_path (const gchar *program);
368
369 gchar*
370 g_find_program_in_path (const gchar *program)
371 {
372   const gchar *last_dot = strrchr (program, '.');
373
374   if (last_dot == NULL ||
375       strchr (last_dot, '\\') != NULL ||
376       strchr (last_dot, '/') != NULL)
377     {
378       const gint program_length = strlen (program);
379       gchar *pathext = g_build_path (";",
380                                      ".exe;.cmd;.bat;.com",
381                                      g_getenv ("PATHEXT"),
382                                      NULL);
383       gchar *p;
384       gchar *decorated_program;
385       gchar *retval;
386
387       p = pathext;
388       do
389         {
390           gchar *q = my_strchrnul (p, ';');
391
392           decorated_program = g_malloc (program_length + (q-p) + 1);
393           memcpy (decorated_program, program, program_length);
394           memcpy (decorated_program+program_length, p, q-p);
395           decorated_program [program_length + (q-p)] = '\0';
396           
397           retval = inner_find_program_in_path (decorated_program);
398           g_free (decorated_program);
399
400           if (retval != NULL)
401             {
402               g_free (pathext);
403               return retval;
404             }
405           p = q;
406         } while (*p++ != '\0');
407       g_free (pathext);
408       return NULL;
409     }
410   else
411     return inner_find_program_in_path (program);
412 }
413
414 #endif
415
416 /**
417  * g_find_program_in_path:
418  * @program: a program name in the GLib file name encoding
419  * 
420  * Locates the first executable named @program in the user's path, in the
421  * same way that execvp() would locate it. Returns an allocated string
422  * with the absolute path name, or %NULL if the program is not found in
423  * the path. If @program is already an absolute path, returns a copy of
424  * @program if @program exists and is executable, and %NULL otherwise.
425  *  
426  * On Windows, if @program does not have a file type suffix, tries
427  * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
428  * the <envar>PATHEXT</envar> environment variable. 
429  * 
430  * On Windows, it looks for the file in the same way as CreateProcess() 
431  * would. This means first in the directory where the executing
432  * program was loaded from, then in the current directory, then in the
433  * Windows 32-bit system directory, then in the Windows directory, and
434  * finally in the directories in the <envar>PATH</envar> environment 
435  * variable. If the program is found, the return value contains the 
436  * full name including the type suffix.
437  *
438  * Return value: absolute path, or %NULL
439  **/
440 #ifdef G_OS_WIN32
441 static gchar *
442 inner_find_program_in_path (const gchar *program)
443 #else
444 gchar*
445 g_find_program_in_path (const gchar *program)
446 #endif
447 {
448   const gchar *path, *p;
449   gchar *name, *freeme;
450 #ifdef G_OS_WIN32
451   const gchar *path_copy;
452   gchar *filename = NULL, *appdir = NULL;
453   gchar *sysdir = NULL, *windir = NULL;
454   int n;
455   wchar_t wfilename[MAXPATHLEN], wsysdir[MAXPATHLEN],
456     wwindir[MAXPATHLEN];
457 #endif
458   gsize len;
459   gsize pathlen;
460
461   g_return_val_if_fail (program != NULL, NULL);
462
463   /* If it is an absolute path, or a relative path including subdirectories,
464    * don't look in PATH.
465    */
466   if (g_path_is_absolute (program)
467       || strchr (program, G_DIR_SEPARATOR) != NULL
468 #ifdef G_OS_WIN32
469       || strchr (program, '/') != NULL
470 #endif
471       )
472     {
473       if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&
474           !g_file_test (program, G_FILE_TEST_IS_DIR))
475         return g_strdup (program);
476       else
477         return NULL;
478     }
479   
480   path = g_getenv ("PATH");
481 #if defined(G_OS_UNIX) || defined(G_OS_BEOS)
482   if (path == NULL)
483     {
484       /* There is no `PATH' in the environment.  The default
485        * search path in GNU libc is the current directory followed by
486        * the path `confstr' returns for `_CS_PATH'.
487        */
488       
489       /* In GLib we put . last, for security, and don't use the
490        * unportable confstr(); UNIX98 does not actually specify
491        * what to search if PATH is unset. POSIX may, dunno.
492        */
493       
494       path = "/bin:/usr/bin:.";
495     }
496 #else
497   n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);
498   if (n > 0 && n < MAXPATHLEN)
499     filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);
500   
501   n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);
502   if (n > 0 && n < MAXPATHLEN)
503     sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);
504   
505   n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);
506   if (n > 0 && n < MAXPATHLEN)
507     windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);
508   
509   if (filename)
510     {
511       appdir = g_path_get_dirname (filename);
512       g_free (filename);
513     }
514   
515   path = g_strdup (path);
516
517   if (windir)
518     {
519       const gchar *tem = path;
520       path = g_strconcat (windir, ";", path, NULL);
521       g_free ((gchar *) tem);
522       g_free (windir);
523     }
524   
525   if (sysdir)
526     {
527       const gchar *tem = path;
528       path = g_strconcat (sysdir, ";", path, NULL);
529       g_free ((gchar *) tem);
530       g_free (sysdir);
531     }
532   
533   {
534     const gchar *tem = path;
535     path = g_strconcat (".;", path, NULL);
536     g_free ((gchar *) tem);
537   }
538   
539   if (appdir)
540     {
541       const gchar *tem = path;
542       path = g_strconcat (appdir, ";", path, NULL);
543       g_free ((gchar *) tem);
544       g_free (appdir);
545     }
546
547   path_copy = path;
548 #endif
549   
550   len = strlen (program) + 1;
551   pathlen = strlen (path);
552   freeme = name = g_malloc (pathlen + len + 1);
553   
554   /* Copy the file name at the top, including '\0'  */
555   memcpy (name + pathlen + 1, program, len);
556   name = name + pathlen;
557   /* And add the slash before the filename  */
558   *name = G_DIR_SEPARATOR;
559   
560   p = path;
561   do
562     {
563       char *startp;
564
565       path = p;
566       p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
567
568       if (p == path)
569         /* Two adjacent colons, or a colon at the beginning or the end
570          * of `PATH' means to search the current directory.
571          */
572         startp = name + 1;
573       else
574         startp = memcpy (name - (p - path), path, p - path);
575
576       if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE) &&
577           !g_file_test (startp, G_FILE_TEST_IS_DIR))
578         {
579           gchar *ret;
580           ret = g_strdup (startp);
581           g_free (freeme);
582 #ifdef G_OS_WIN32
583           g_free ((gchar *) path_copy);
584 #endif
585           return ret;
586         }
587     }
588   while (*p++ != '\0');
589   
590   g_free (freeme);
591 #ifdef G_OS_WIN32
592   g_free ((gchar *) path_copy);
593 #endif
594
595   return NULL;
596 }
597
598 static gboolean
599 debug_key_matches (const gchar *key,
600                    const gchar *token,
601                    guint        length)
602 {
603   for (; length; length--, key++, token++)
604     {
605       char k = (*key   == '_') ? '-' : tolower (*key  );
606       char t = (*token == '_') ? '-' : tolower (*token);
607
608       if (k != t)
609         return FALSE;
610     }
611
612   return *key == '\0';
613 }
614
615 /**
616  * g_parse_debug_string:
617  * @string: a list of debug options separated by colons, spaces, or
618  * commas, or %NULL.
619  * @keys: pointer to an array of #GDebugKey which associate 
620  *     strings with bit flags.
621  * @nkeys: the number of #GDebugKey<!-- -->s in the array.
622  *
623  * Parses a string containing debugging options
624  * into a %guint containing bit flags. This is used 
625  * within GDK and GTK+ to parse the debug options passed on the
626  * command line or through environment variables.
627  *
628  * If @string is equal to "all", all flags are set.  If @string
629  * is equal to "help", all the available keys in @keys are printed
630  * out to standard error.
631  *
632  * Returns: the combined set of bit flags.
633  */
634 guint        
635 g_parse_debug_string  (const gchar     *string, 
636                        const GDebugKey *keys, 
637                        guint            nkeys)
638 {
639   guint i;
640   guint result = 0;
641   
642   if (string == NULL)
643     return 0;
644
645   /* this function is used by gmem.c/gslice.c initialization code,
646    * so introducing malloc dependencies here would require adaptions
647    * of those code portions.
648    */
649   
650   if (!g_ascii_strcasecmp (string, "all"))
651     {
652       for (i=0; i<nkeys; i++)
653         result |= keys[i].value;
654     }
655   else if (!g_ascii_strcasecmp (string, "help"))
656     {
657       /* using stdio directly for the reason stated above */
658       fprintf (stderr, "Supported debug values: ");
659       for (i=0; i<nkeys; i++)
660         fprintf (stderr, " %s", keys[i].key);
661       fprintf (stderr, "\n");
662     }
663   else
664     {
665       const gchar *p = string;
666       const gchar *q;
667       
668       while (*p)
669         {
670           q = strpbrk (p, ":;, \t");
671           if (!q)
672             q = p + strlen(p);
673           
674           for (i = 0; i < nkeys; i++)
675             if (debug_key_matches (keys[i].key, p, q - p))
676               result |= keys[i].value;
677           
678           p = q;
679           if (*p)
680             p++;
681         }
682     }
683   
684   return result;
685 }
686
687 /**
688  * g_basename:
689  * @file_name: the name of the file.
690  * 
691  * Gets the name of the file without any leading directory components.  
692  * It returns a pointer into the given file name string.
693  * 
694  * Return value: the name of the file without any leading directory components.
695  *
696  * Deprecated:2.2: Use g_path_get_basename() instead, but notice that
697  * g_path_get_basename() allocates new memory for the returned string, unlike
698  * this function which returns a pointer into the argument.
699  **/
700 G_CONST_RETURN gchar*
701 g_basename (const gchar    *file_name)
702 {
703   register gchar *base;
704   
705   g_return_val_if_fail (file_name != NULL, NULL);
706   
707   base = strrchr (file_name, G_DIR_SEPARATOR);
708
709 #ifdef G_OS_WIN32
710   {
711     gchar *q = strrchr (file_name, '/');
712     if (base == NULL || (q != NULL && q > base))
713         base = q;
714   }
715 #endif
716
717   if (base)
718     return base + 1;
719
720 #ifdef G_OS_WIN32
721   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
722     return (gchar*) file_name + 2;
723 #endif /* G_OS_WIN32 */
724   
725   return (gchar*) file_name;
726 }
727
728 /**
729  * g_path_get_basename:
730  * @file_name: the name of the file.
731  *
732  * Gets the last component of the filename. If @file_name ends with a 
733  * directory separator it gets the component before the last slash. If 
734  * @file_name consists only of directory separators (and on Windows, 
735  * possibly a drive letter), a single separator is returned. If
736  * @file_name is empty, it gets ".".
737  *
738  * Return value: a newly allocated string containing the last component of 
739  *   the filename.
740  */
741 gchar*
742 g_path_get_basename (const gchar   *file_name)
743 {
744   register gssize base;             
745   register gssize last_nonslash;    
746   gsize len;    
747   gchar *retval;
748  
749   g_return_val_if_fail (file_name != NULL, NULL);
750
751   if (file_name[0] == '\0')
752     /* empty string */
753     return g_strdup (".");
754   
755   last_nonslash = strlen (file_name) - 1;
756
757   while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash]))
758     last_nonslash--;
759
760   if (last_nonslash == -1)
761     /* string only containing slashes */
762     return g_strdup (G_DIR_SEPARATOR_S);
763
764 #ifdef G_OS_WIN32
765   if (last_nonslash == 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
766     /* string only containing slashes and a drive */
767     return g_strdup (G_DIR_SEPARATOR_S);
768 #endif /* G_OS_WIN32 */
769
770   base = last_nonslash;
771
772   while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base]))
773     base--;
774
775 #ifdef G_OS_WIN32
776   if (base == -1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
777     base = 1;
778 #endif /* G_OS_WIN32 */
779
780   len = last_nonslash - base;
781   retval = g_malloc (len + 1);
782   memcpy (retval, file_name + base + 1, len);
783   retval [len] = '\0';
784   return retval;
785 }
786
787 /**
788  * g_path_is_absolute:
789  * @file_name: a file name.
790  *
791  * Returns %TRUE if the given @file_name is an absolute file name,
792  * i.e. it contains a full path from the root directory such as "/usr/local"
793  * on UNIX or "C:\windows" on Windows systems.
794  *
795  * Returns: %TRUE if @file_name is an absolute path. 
796  */
797 gboolean
798 g_path_is_absolute (const gchar *file_name)
799 {
800   g_return_val_if_fail (file_name != NULL, FALSE);
801   
802   if (G_IS_DIR_SEPARATOR (file_name[0]))
803     return TRUE;
804
805 #ifdef G_OS_WIN32
806   /* Recognize drive letter on native Windows */
807   if (g_ascii_isalpha (file_name[0]) && 
808       file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
809     return TRUE;
810 #endif /* G_OS_WIN32 */
811
812   return FALSE;
813 }
814
815 /**
816  * g_path_skip_root:
817  * @file_name: a file name.
818  *
819  * Returns a pointer into @file_name after the root component, i.e. after
820  * the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute
821  * path it returns %NULL.
822  *
823  * Returns: a pointer into @file_name after the root component.
824  */
825 G_CONST_RETURN gchar*
826 g_path_skip_root (const gchar *file_name)
827 {
828   g_return_val_if_fail (file_name != NULL, NULL);
829   
830 #ifdef G_PLATFORM_WIN32
831   /* Skip \\server\share or //server/share */
832   if (G_IS_DIR_SEPARATOR (file_name[0]) &&
833       G_IS_DIR_SEPARATOR (file_name[1]) &&
834       file_name[2] &&
835       !G_IS_DIR_SEPARATOR (file_name[2]))
836     {
837       gchar *p;
838
839       p = strchr (file_name + 2, G_DIR_SEPARATOR);
840 #ifdef G_OS_WIN32
841       {
842         gchar *q = strchr (file_name + 2, '/');
843         if (p == NULL || (q != NULL && q < p))
844           p = q;
845       }
846 #endif
847       if (p &&
848           p > file_name + 2 &&
849           p[1])
850         {
851           file_name = p + 1;
852
853           while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0]))
854             file_name++;
855
856           /* Possibly skip a backslash after the share name */
857           if (G_IS_DIR_SEPARATOR (file_name[0]))
858             file_name++;
859
860           return (gchar *)file_name;
861         }
862     }
863 #endif
864   
865   /* Skip initial slashes */
866   if (G_IS_DIR_SEPARATOR (file_name[0]))
867     {
868       while (G_IS_DIR_SEPARATOR (file_name[0]))
869         file_name++;
870       return (gchar *)file_name;
871     }
872
873 #ifdef G_OS_WIN32
874   /* Skip X:\ */
875   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
876     return (gchar *)file_name + 3;
877 #endif
878
879   return NULL;
880 }
881
882 /**
883  * g_path_get_dirname:
884  * @file_name: the name of the file.
885  *
886  * Gets the directory components of a file name.  If the file name has no
887  * directory components "." is returned.  The returned string should be
888  * freed when no longer needed.
889  * 
890  * Returns: the directory components of the file.
891  */
892 gchar*
893 g_path_get_dirname (const gchar    *file_name)
894 {
895   register gchar *base;
896   register gsize len;    
897   
898   g_return_val_if_fail (file_name != NULL, NULL);
899   
900   base = strrchr (file_name, G_DIR_SEPARATOR);
901 #ifdef G_OS_WIN32
902   {
903     gchar *q = strrchr (file_name, '/');
904     if (base == NULL || (q != NULL && q > base))
905         base = q;
906   }
907 #endif
908   if (!base)
909     {
910 #ifdef G_OS_WIN32
911       if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
912         {
913           gchar drive_colon_dot[4];
914
915           drive_colon_dot[0] = file_name[0];
916           drive_colon_dot[1] = ':';
917           drive_colon_dot[2] = '.';
918           drive_colon_dot[3] = '\0';
919
920           return g_strdup (drive_colon_dot);
921         }
922 #endif
923     return g_strdup (".");
924     }
925
926   while (base > file_name && G_IS_DIR_SEPARATOR (*base))
927     base--;
928
929 #ifdef G_OS_WIN32
930   /* base points to the char before the last slash.
931    *
932    * In case file_name is the root of a drive (X:\) or a child of the
933    * root of a drive (X:\foo), include the slash.
934    *
935    * In case file_name is the root share of an UNC path
936    * (\\server\share), add a slash, returning \\server\share\ .
937    *
938    * In case file_name is a direct child of a share in an UNC path
939    * (\\server\share\foo), include the slash after the share name,
940    * returning \\server\share\ .
941    */
942   if (base == file_name + 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
943     base++;
944   else if (G_IS_DIR_SEPARATOR (file_name[0]) &&
945            G_IS_DIR_SEPARATOR (file_name[1]) &&
946            file_name[2] &&
947            !G_IS_DIR_SEPARATOR (file_name[2]) &&
948            base >= file_name + 2)
949     {
950       const gchar *p = file_name + 2;
951       while (*p && !G_IS_DIR_SEPARATOR (*p))
952         p++;
953       if (p == base + 1)
954         {
955           len = (guint) strlen (file_name) + 1;
956           base = g_new (gchar, len + 1);
957           strcpy (base, file_name);
958           base[len-1] = G_DIR_SEPARATOR;
959           base[len] = 0;
960           return base;
961         }
962       if (G_IS_DIR_SEPARATOR (*p))
963         {
964           p++;
965           while (*p && !G_IS_DIR_SEPARATOR (*p))
966             p++;
967           if (p == base + 1)
968             base++;
969         }
970     }
971 #endif
972
973   len = (guint) 1 + base - file_name;
974   
975   base = g_new (gchar, len + 1);
976   g_memmove (base, file_name, len);
977   base[len] = 0;
978   
979   return base;
980 }
981
982 /**
983  * g_get_current_dir:
984  *
985  * Gets the current directory.
986  * The returned string should be freed when no longer needed. The encoding 
987  * of the returned string is system defined. On Windows, it is always UTF-8.
988  * 
989  * Returns: the current directory.
990  */
991 gchar*
992 g_get_current_dir (void)
993 {
994 #ifdef G_OS_WIN32
995
996   gchar *dir = NULL;
997   wchar_t dummy[2], *wdir;
998   int len;
999
1000   len = GetCurrentDirectoryW (2, dummy);
1001   wdir = g_new (wchar_t, len);
1002
1003   if (GetCurrentDirectoryW (len, wdir) == len - 1)
1004     dir = g_utf16_to_utf8 (wdir, -1, NULL, NULL, NULL);
1005   
1006   g_free (wdir);
1007
1008   if (dir == NULL)
1009     dir = g_strdup ("\\");
1010
1011   return dir;
1012
1013 #else
1014
1015   gchar *buffer = NULL;
1016   gchar *dir = NULL;
1017   static gulong max_len = 0;
1018
1019   if (max_len == 0) 
1020     max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
1021   
1022   /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
1023    * and, if that wasn't bad enough, hangs in doing so.
1024    */
1025 #if     (defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
1026   buffer = g_new (gchar, max_len + 1);
1027   *buffer = 0;
1028   dir = getwd (buffer);
1029 #else   /* !sun || !HAVE_GETCWD */
1030   while (max_len < G_MAXULONG / 2)
1031     {
1032       g_free (buffer);
1033       buffer = g_new (gchar, max_len + 1);
1034       *buffer = 0;
1035       dir = getcwd (buffer, max_len);
1036
1037       if (dir || errno != ERANGE)
1038         break;
1039
1040       max_len *= 2;
1041     }
1042 #endif  /* !sun || !HAVE_GETCWD */
1043   
1044   if (!dir || !*buffer)
1045     {
1046       /* hm, should we g_error() out here?
1047        * this can happen if e.g. "./" has mode \0000
1048        */
1049       buffer[0] = G_DIR_SEPARATOR;
1050       buffer[1] = 0;
1051     }
1052
1053   dir = g_strdup (buffer);
1054   g_free (buffer);
1055   
1056   return dir;
1057 #endif /* !Win32 */
1058 }
1059
1060 /**
1061  * g_getenv:
1062  * @variable: the environment variable to get, in the GLib file name encoding.
1063  * 
1064  * Returns the value of an environment variable. The name and value
1065  * are in the GLib file name encoding. On UNIX, this means the actual
1066  * bytes which might or might not be in some consistent character set
1067  * and encoding. On Windows, it is in UTF-8. On Windows, in case the
1068  * environment variable's value contains references to other
1069  * environment variables, they are expanded.
1070  * 
1071  * Return value: the value of the environment variable, or %NULL if
1072  * the environment variable is not found. The returned string may be
1073  * overwritten by the next call to g_getenv(), g_setenv() or
1074  * g_unsetenv().
1075  **/
1076 G_CONST_RETURN gchar*
1077 g_getenv (const gchar *variable)
1078 {
1079 #ifndef G_OS_WIN32
1080
1081   g_return_val_if_fail (variable != NULL, NULL);
1082
1083   return getenv (variable);
1084
1085 #else /* G_OS_WIN32 */
1086
1087   GQuark quark;
1088   gchar *value;
1089   wchar_t dummy[2], *wname, *wvalue;
1090   int len;
1091
1092   g_return_val_if_fail (variable != NULL, NULL);
1093   g_return_val_if_fail (g_utf8_validate (variable, -1, NULL), NULL);
1094
1095   /* On Windows NT, it is relatively typical that environment
1096    * variables contain references to other environment variables. If
1097    * so, use ExpandEnvironmentStrings(). (In an ideal world, such
1098    * environment variables would be stored in the Registry as
1099    * REG_EXPAND_SZ type values, and would then get automatically
1100    * expanded before a program sees them. But there is broken software
1101    * that stores environment variables as REG_SZ values even if they
1102    * contain references to other environment variables.)
1103    */
1104
1105   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1106
1107   len = GetEnvironmentVariableW (wname, dummy, 2);
1108
1109   if (len == 0)
1110     {
1111       g_free (wname);
1112       return NULL;
1113     }
1114   else if (len == 1)
1115     len = 2;
1116
1117   wvalue = g_new (wchar_t, len);
1118
1119   if (GetEnvironmentVariableW (wname, wvalue, len) != len - 1)
1120     {
1121       g_free (wname);
1122       g_free (wvalue);
1123       return NULL;
1124     }
1125
1126   if (wcschr (wvalue, L'%') != NULL)
1127     {
1128       wchar_t *tem = wvalue;
1129
1130       len = ExpandEnvironmentStringsW (wvalue, dummy, 2);
1131
1132       if (len > 0)
1133         {
1134           wvalue = g_new (wchar_t, len);
1135
1136           if (ExpandEnvironmentStringsW (tem, wvalue, len) != len)
1137             {
1138               g_free (wvalue);
1139               wvalue = tem;
1140             }
1141           else
1142             g_free (tem);
1143         }
1144     }
1145
1146   value = g_utf16_to_utf8 (wvalue, -1, NULL, NULL, NULL);
1147
1148   g_free (wname);
1149   g_free (wvalue);
1150
1151   quark = g_quark_from_string (value);
1152   g_free (value);
1153   
1154   return g_quark_to_string (quark);
1155
1156 #endif /* G_OS_WIN32 */
1157 }
1158
1159 /* _g_getenv_nomalloc
1160  * this function does a getenv() without doing any kind of allocation
1161  * through glib. it's suitable for chars <= 127 only (both, for the
1162  * variable name and the contents) and for contents < 1024 chars in
1163  * length. also, it aliases "" to a NULL return value.
1164  **/
1165 const gchar*
1166 _g_getenv_nomalloc (const gchar *variable,
1167                     gchar        buffer[1024])
1168 {
1169   const gchar *retval = getenv (variable);
1170   if (retval && retval[0])
1171     {
1172       gint l = strlen (retval);
1173       if (l < 1024)
1174         {
1175           strncpy (buffer, retval, l);
1176           buffer[l] = 0;
1177           return buffer;
1178         }
1179     }
1180   return NULL;
1181 }
1182
1183 /**
1184  * g_setenv:
1185  * @variable: the environment variable to set, must not contain '='.
1186  * @value: the value for to set the variable to.
1187  * @overwrite: whether to change the variable if it already exists.
1188  *
1189  * Sets an environment variable. Both the variable's name and value
1190  * should be in the GLib file name encoding. On UNIX, this means that
1191  * they can be any sequence of bytes. On Windows, they should be in
1192  * UTF-8.
1193  *
1194  * Note that on some systems, when variables are overwritten, the memory 
1195  * used for the previous variables and its value isn't reclaimed.
1196  *
1197  * Returns: %FALSE if the environment variable couldn't be set.
1198  *
1199  * Since: 2.4
1200  */
1201 gboolean
1202 g_setenv (const gchar *variable, 
1203           const gchar *value, 
1204           gboolean     overwrite)
1205 {
1206 #ifndef G_OS_WIN32
1207
1208   gint result;
1209 #ifndef HAVE_SETENV
1210   gchar *string;
1211 #endif
1212
1213   g_return_val_if_fail (variable != NULL, FALSE);
1214   g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
1215
1216 #ifdef HAVE_SETENV
1217   result = setenv (variable, value, overwrite);
1218 #else
1219   if (!overwrite && getenv (variable) != NULL)
1220     return TRUE;
1221   
1222   /* This results in a leak when you overwrite existing
1223    * settings. It would be fairly easy to fix this by keeping
1224    * our own parallel array or hash table.
1225    */
1226   string = g_strconcat (variable, "=", value, NULL);
1227   result = putenv (string);
1228 #endif
1229   return result == 0;
1230
1231 #else /* G_OS_WIN32 */
1232
1233   gboolean retval;
1234   wchar_t *wname, *wvalue, *wassignment;
1235   gchar *tem;
1236
1237   g_return_val_if_fail (variable != NULL, FALSE);
1238   g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
1239   g_return_val_if_fail (g_utf8_validate (variable, -1, NULL), FALSE);
1240   g_return_val_if_fail (g_utf8_validate (value, -1, NULL), FALSE);
1241
1242   if (!overwrite && g_getenv (variable) != NULL)
1243     return TRUE;
1244
1245   /* We want to (if possible) set both the environment variable copy
1246    * kept by the C runtime and the one kept by the system.
1247    *
1248    * We can't use only the C runtime's putenv or _wputenv() as that
1249    * won't work for arbitrary Unicode strings in a "non-Unicode" app
1250    * (with main() and not wmain()). In a "main()" app the C runtime
1251    * initializes the C runtime's environment table by converting the
1252    * real (wide char) environment variables to system codepage, thus
1253    * breaking those that aren't representable in the system codepage.
1254    *
1255    * As the C runtime's putenv() will also set the system copy, we do
1256    * the putenv() first, then call SetEnvironmentValueW ourselves.
1257    */
1258
1259   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1260   wvalue = g_utf8_to_utf16 (value, -1, NULL, NULL, NULL);
1261   tem = g_strconcat (variable, "=", value, NULL);
1262   wassignment = g_utf8_to_utf16 (tem, -1, NULL, NULL, NULL);
1263     
1264   g_free (tem);
1265   _wputenv (wassignment);
1266   g_free (wassignment);
1267
1268   retval = (SetEnvironmentVariableW (wname, wvalue) != 0);
1269
1270   g_free (wname);
1271   g_free (wvalue);
1272
1273   return retval;
1274
1275 #endif /* G_OS_WIN32 */
1276 }
1277
1278 #ifdef HAVE__NSGETENVIRON
1279 #define environ (*_NSGetEnviron())
1280 #elif !defined(G_OS_WIN32)
1281
1282 /* According to the Single Unix Specification, environ is not in 
1283  * any system header, although unistd.h often declares it.
1284  */
1285 extern char **environ;
1286 #endif
1287
1288 /**
1289  * g_unsetenv:
1290  * @variable: the environment variable to remove, must not contain '='.
1291  * 
1292  * Removes an environment variable from the environment.
1293  *
1294  * Note that on some systems, when variables are overwritten, the memory 
1295  * used for the previous variables and its value isn't reclaimed.
1296  * Furthermore, this function can't be guaranteed to operate in a 
1297  * threadsafe way.
1298  *
1299  * Since: 2.4 
1300  **/
1301 void
1302 g_unsetenv (const gchar *variable)
1303 {
1304 #ifndef G_OS_WIN32
1305
1306 #ifdef HAVE_UNSETENV
1307   g_return_if_fail (variable != NULL);
1308   g_return_if_fail (strchr (variable, '=') == NULL);
1309
1310   unsetenv (variable);
1311 #else /* !HAVE_UNSETENV */
1312   int len;
1313   gchar **e, **f;
1314
1315   g_return_if_fail (variable != NULL);
1316   g_return_if_fail (strchr (variable, '=') == NULL);
1317
1318   len = strlen (variable);
1319   
1320   /* Mess directly with the environ array.
1321    * This seems to be the only portable way to do this.
1322    *
1323    * Note that we remove *all* environment entries for
1324    * the variable name, not just the first.
1325    */
1326   e = f = environ;
1327   while (*e != NULL) 
1328     {
1329       if (strncmp (*e, variable, len) != 0 || (*e)[len] != '=') 
1330         {
1331           *f = *e;
1332           f++;
1333         }
1334       e++;
1335     }
1336   *f = NULL;
1337 #endif /* !HAVE_UNSETENV */
1338
1339 #else  /* G_OS_WIN32 */
1340
1341   wchar_t *wname, *wassignment;
1342   gchar *tem;
1343
1344   g_return_if_fail (variable != NULL);
1345   g_return_if_fail (strchr (variable, '=') == NULL);
1346   g_return_if_fail (g_utf8_validate (variable, -1, NULL));
1347
1348   wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
1349   tem = g_strconcat (variable, "=", NULL);
1350   wassignment = g_utf8_to_utf16 (tem, -1, NULL, NULL, NULL);
1351     
1352   g_free (tem);
1353   _wputenv (wassignment);
1354   g_free (wassignment);
1355
1356   SetEnvironmentVariableW (wname, NULL);
1357
1358   g_free (wname);
1359
1360 #endif /* G_OS_WIN32 */
1361 }
1362
1363 /**
1364  * g_listenv:
1365  *
1366  * Gets the names of all variables set in the environment.
1367  * 
1368  * Returns: a %NULL-terminated list of strings which must be freed
1369  * with g_strfreev().
1370  *
1371  * Programs that want to be portable to Windows should typically use
1372  * this function and g_getenv() instead of using the environ array
1373  * from the C library directly. On Windows, the strings in the environ
1374  * array are in system codepage encoding, while in most of the typical
1375  * use cases for environment variables in GLib-using programs you want
1376  * the UTF-8 encoding that this function and g_getenv() provide.
1377  *
1378  * Since: 2.8
1379  */
1380 gchar **
1381 g_listenv (void)
1382 {
1383 #ifndef G_OS_WIN32
1384   gchar **result, *eq;
1385   gint len, i, j;
1386
1387   len = g_strv_length (environ);
1388   result = g_new0 (gchar *, len + 1);
1389   
1390   j = 0;
1391   for (i = 0; i < len; i++)
1392     {
1393       eq = strchr (environ[i], '=');
1394       if (eq)
1395         result[j++] = g_strndup (environ[i], eq - environ[i]);
1396     }
1397
1398   result[j] = NULL;
1399
1400   return result;
1401 #else
1402   gchar **result, *eq;
1403   gint len = 0, j;
1404   wchar_t *p, *q;
1405
1406   p = (wchar_t *) GetEnvironmentStringsW ();
1407   if (p != NULL)
1408     {
1409       q = p;
1410       while (*q)
1411         {
1412           q += wcslen (q) + 1;
1413           len++;
1414         }
1415     }
1416   result = g_new0 (gchar *, len + 1);
1417
1418   j = 0;
1419   q = p;
1420   while (*q)
1421     {
1422       result[j] = g_utf16_to_utf8 (q, -1, NULL, NULL, NULL);
1423       if (result[j] != NULL)
1424         {
1425           eq = strchr (result[j], '=');
1426           if (eq && eq > result[j])
1427             {
1428               *eq = '\0';
1429               j++;
1430             }
1431           else
1432             g_free (result[j]);
1433         }
1434       q += wcslen (q) + 1;
1435     }
1436   result[j] = NULL;
1437   FreeEnvironmentStringsW (p);
1438
1439   return result;
1440 #endif
1441 }
1442
1443 G_LOCK_DEFINE_STATIC (g_utils_global);
1444
1445 static  gchar   *g_tmp_dir = NULL;
1446 static  gchar   *g_user_name = NULL;
1447 static  gchar   *g_real_name = NULL;
1448 static  gchar   *g_home_dir = NULL;
1449 static  gchar   *g_host_name = NULL;
1450
1451 #ifdef G_OS_WIN32
1452 /* System codepage versions of the above, kept at file level so that they,
1453  * too, are produced only once.
1454  */
1455 static  gchar   *g_tmp_dir_cp = NULL;
1456 static  gchar   *g_user_name_cp = NULL;
1457 static  gchar   *g_real_name_cp = NULL;
1458 static  gchar   *g_home_dir_cp = NULL;
1459 #endif
1460
1461 static  gchar   *g_user_data_dir = NULL;
1462 static  gchar  **g_system_data_dirs = NULL;
1463 static  gchar   *g_user_cache_dir = NULL;
1464 static  gchar   *g_user_config_dir = NULL;
1465 static  gchar  **g_system_config_dirs = NULL;
1466
1467 static  gchar  **g_user_special_dirs = NULL;
1468
1469 /* fifteen minutes of fame for everybody */
1470 #define G_USER_DIRS_EXPIRE      15 * 60
1471
1472 #ifdef G_OS_WIN32
1473
1474 static gchar *
1475 get_special_folder (int csidl)
1476 {
1477   wchar_t path[MAX_PATH+1];
1478   HRESULT hr;
1479   LPITEMIDLIST pidl = NULL;
1480   BOOL b;
1481   gchar *retval = NULL;
1482
1483   hr = SHGetSpecialFolderLocation (NULL, csidl, &pidl);
1484   if (hr == S_OK)
1485     {
1486       b = SHGetPathFromIDListW (pidl, path);
1487       if (b)
1488         retval = g_utf16_to_utf8 (path, -1, NULL, NULL, NULL);
1489       CoTaskMemFree (pidl);
1490     }
1491   return retval;
1492 }
1493
1494 static char *
1495 get_windows_directory_root (void)
1496 {
1497   wchar_t wwindowsdir[MAX_PATH];
1498
1499   if (GetWindowsDirectoryW (wwindowsdir, G_N_ELEMENTS (wwindowsdir)))
1500     {
1501       /* Usually X:\Windows, but in terminal server environments
1502        * might be an UNC path, AFAIK.
1503        */
1504       char *windowsdir = g_utf16_to_utf8 (wwindowsdir, -1, NULL, NULL, NULL);
1505       char *p;
1506
1507       if (windowsdir == NULL)
1508         return g_strdup ("C:\\");
1509
1510       p = (char *) g_path_skip_root (windowsdir);
1511       if (G_IS_DIR_SEPARATOR (p[-1]) && p[-2] != ':')
1512         p--;
1513       *p = '\0';
1514       return windowsdir;
1515     }
1516   else
1517     return g_strdup ("C:\\");
1518 }
1519
1520 #endif
1521
1522 /* HOLDS: g_utils_global_lock */
1523 static void
1524 g_get_any_init_do (void)
1525 {
1526   gchar hostname[100];
1527
1528   g_tmp_dir = g_strdup (g_getenv ("TMPDIR"));
1529   if (!g_tmp_dir)
1530     g_tmp_dir = g_strdup (g_getenv ("TMP"));
1531   if (!g_tmp_dir)
1532     g_tmp_dir = g_strdup (g_getenv ("TEMP"));
1533
1534 #ifdef G_OS_WIN32
1535   if (!g_tmp_dir)
1536     g_tmp_dir = get_windows_directory_root ();
1537 #else  
1538 #ifdef P_tmpdir
1539   if (!g_tmp_dir)
1540     {
1541       gsize k;    
1542       g_tmp_dir = g_strdup (P_tmpdir);
1543       k = strlen (g_tmp_dir);
1544       if (k > 1 && G_IS_DIR_SEPARATOR (g_tmp_dir[k - 1]))
1545         g_tmp_dir[k - 1] = '\0';
1546     }
1547 #endif
1548   
1549   if (!g_tmp_dir)
1550     {
1551       g_tmp_dir = g_strdup ("/tmp");
1552     }
1553 #endif  /* !G_OS_WIN32 */
1554   
1555 #ifdef G_OS_WIN32
1556   /* We check $HOME first for Win32, though it is a last resort for Unix
1557    * where we prefer the results of getpwuid().
1558    */
1559   g_home_dir = g_strdup (g_getenv ("HOME"));
1560
1561   /* Only believe HOME if it is an absolute path and exists */
1562   if (g_home_dir)
1563     {
1564       if (!(g_path_is_absolute (g_home_dir) &&
1565             g_file_test (g_home_dir, G_FILE_TEST_IS_DIR)))
1566         {
1567           g_free (g_home_dir);
1568           g_home_dir = NULL;
1569         }
1570     }
1571   
1572   /* In case HOME is Unix-style (it happens), convert it to
1573    * Windows style.
1574    */
1575   if (g_home_dir)
1576     {
1577       gchar *p;
1578       while ((p = strchr (g_home_dir, '/')) != NULL)
1579         *p = '\\';
1580     }
1581
1582   if (!g_home_dir)
1583     {
1584       /* USERPROFILE is probably the closest equivalent to $HOME? */
1585       if (g_getenv ("USERPROFILE") != NULL)
1586         g_home_dir = g_strdup (g_getenv ("USERPROFILE"));
1587     }
1588
1589   if (!g_home_dir)
1590     g_home_dir = get_special_folder (CSIDL_PROFILE);
1591   
1592   if (!g_home_dir)
1593     g_home_dir = get_windows_directory_root ();
1594 #endif /* G_OS_WIN32 */
1595   
1596 #ifdef HAVE_PWD_H
1597   {
1598     struct passwd *pw = NULL;
1599     gpointer buffer = NULL;
1600     gint error;
1601     gchar *logname;
1602
1603 #  if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
1604     struct passwd pwd;
1605 #    ifdef _SC_GETPW_R_SIZE_MAX  
1606     /* This reurns the maximum length */
1607     glong bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
1608     
1609     if (bufsize < 0)
1610       bufsize = 64;
1611 #    else /* _SC_GETPW_R_SIZE_MAX */
1612     glong bufsize = 64;
1613 #    endif /* _SC_GETPW_R_SIZE_MAX */
1614
1615     logname = (gchar *) g_getenv ("LOGNAME");
1616         
1617     do
1618       {
1619         g_free (buffer);
1620         /* we allocate 6 extra bytes to work around a bug in 
1621          * Mac OS < 10.3. See #156446
1622          */
1623         buffer = g_malloc (bufsize + 6);
1624         errno = 0;
1625         
1626 #    ifdef HAVE_POSIX_GETPWUID_R
1627         if (logname) {
1628           error = getpwnam_r (logname, &pwd, buffer, bufsize, &pw);
1629           if (!pw || (pw->pw_uid != getuid ())) {
1630             /* LOGNAME is lying, fall back to looking up the uid */
1631             error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
1632           }
1633         } else {
1634           error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
1635         }
1636         error = error < 0 ? errno : error;
1637 #    else /* HAVE_NONPOSIX_GETPWUID_R */
1638    /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
1639 #      if defined(_AIX) || defined(__hpux)
1640         error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1641         pw = error == 0 ? &pwd : NULL;
1642 #      else /* !_AIX */
1643         if (logname) {
1644           pw = getpwnam_r (logname, &pwd, buffer, bufsize);
1645           if (!pw || (pw->pw_uid != getuid ())) {
1646             /* LOGNAME is lying, fall back to looking up the uid */
1647             pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1648           }
1649         } else {
1650           pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
1651         }
1652         error = pw ? 0 : errno;
1653 #      endif /* !_AIX */            
1654 #    endif /* HAVE_NONPOSIX_GETPWUID_R */
1655         
1656         if (!pw)
1657           {
1658             /* we bail out prematurely if the user id can't be found
1659              * (should be pretty rare case actually), or if the buffer
1660              * should be sufficiently big and lookups are still not
1661              * successfull.
1662              */
1663             if (error == 0 || error == ENOENT)
1664               {
1665                 g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
1666                            (gulong) getuid ());
1667                 break;
1668               }
1669             if (bufsize > 32 * 1024)
1670               {
1671                 g_warning ("getpwuid_r(): failed due to: %s.",
1672                            g_strerror (error));
1673                 break;
1674               }
1675             
1676             bufsize *= 2;
1677           }
1678       }
1679     while (!pw);
1680 #  endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
1681     
1682     if (!pw)
1683       {
1684         setpwent ();
1685         pw = getpwuid (getuid ());
1686         endpwent ();
1687       }
1688     if (pw)
1689       {
1690         g_user_name = g_strdup (pw->pw_name);
1691
1692         if (pw->pw_gecos && *pw->pw_gecos != '\0') 
1693           {
1694             gchar **gecos_fields;
1695             gchar **name_parts;
1696
1697             /* split the gecos field and substitute '&' */
1698             gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
1699             name_parts = g_strsplit (gecos_fields[0], "&", 0);
1700             pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
1701             g_real_name = g_strjoinv (pw->pw_name, name_parts);
1702             g_strfreev (gecos_fields);
1703             g_strfreev (name_parts);
1704           }
1705
1706         if (!g_home_dir)
1707           g_home_dir = g_strdup (pw->pw_dir);
1708       }
1709     g_free (buffer);
1710   }
1711   
1712 #else /* !HAVE_PWD_H */
1713   
1714 #ifdef G_OS_WIN32
1715   {
1716     guint len = UNLEN+1;
1717     wchar_t buffer[UNLEN+1];
1718     
1719     if (GetUserNameW (buffer, (LPDWORD) &len))
1720       {
1721         g_user_name = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL);
1722         g_real_name = g_strdup (g_user_name);
1723       }
1724   }
1725 #endif /* G_OS_WIN32 */
1726
1727 #endif /* !HAVE_PWD_H */
1728
1729 #ifndef G_OS_WIN32
1730   if (!g_home_dir)
1731     g_home_dir = g_strdup (g_getenv ("HOME"));
1732 #endif
1733
1734 #ifdef __EMX__
1735   /* change '\\' in %HOME% to '/' */
1736   g_strdelimit (g_home_dir, "\\",'/');
1737 #endif
1738   if (!g_user_name)
1739     g_user_name = g_strdup ("somebody");
1740   if (!g_real_name)
1741     g_real_name = g_strdup ("Unknown");
1742
1743   {
1744 #ifndef G_OS_WIN32
1745     gboolean hostname_fail = (gethostname (hostname, sizeof (hostname)) == -1);
1746 #else
1747     DWORD size = sizeof (hostname);
1748     gboolean hostname_fail = (!GetComputerName (hostname, &size));
1749 #endif
1750     g_host_name = g_strdup (hostname_fail ? "localhost" : hostname);
1751   }
1752
1753 #ifdef G_OS_WIN32
1754   g_tmp_dir_cp = g_locale_from_utf8 (g_tmp_dir, -1, NULL, NULL, NULL);
1755   g_user_name_cp = g_locale_from_utf8 (g_user_name, -1, NULL, NULL, NULL);
1756   g_real_name_cp = g_locale_from_utf8 (g_real_name, -1, NULL, NULL, NULL);
1757
1758   if (!g_tmp_dir_cp)
1759     g_tmp_dir_cp = g_strdup ("\\");
1760   if (!g_user_name_cp)
1761     g_user_name_cp = g_strdup ("somebody");
1762   if (!g_real_name_cp)
1763     g_real_name_cp = g_strdup ("Unknown");
1764
1765   /* home_dir might be NULL, unlike tmp_dir, user_name and
1766    * real_name.
1767    */
1768   if (g_home_dir)
1769     g_home_dir_cp = g_locale_from_utf8 (g_home_dir, -1, NULL, NULL, NULL);
1770   else
1771     g_home_dir_cp = NULL;
1772 #endif /* G_OS_WIN32 */
1773 }
1774
1775 static inline void
1776 g_get_any_init (void)
1777 {
1778   if (!g_tmp_dir)
1779     g_get_any_init_do ();
1780 }
1781
1782 static inline void
1783 g_get_any_init_locked (void)
1784 {
1785   G_LOCK (g_utils_global);
1786   g_get_any_init ();
1787   G_UNLOCK (g_utils_global);
1788 }
1789
1790
1791 /**
1792  * g_get_user_name:
1793  *
1794  * Gets the user name of the current user. The encoding of the returned
1795  * string is system-defined. On UNIX, it might be the preferred file name
1796  * encoding, or something else, and there is no guarantee that it is even
1797  * consistent on a machine. On Windows, it is always UTF-8.
1798  *
1799  * Returns: the user name of the current user.
1800  */
1801 G_CONST_RETURN gchar*
1802 g_get_user_name (void)
1803 {
1804   g_get_any_init_locked ();
1805   return g_user_name;
1806 }
1807
1808 /**
1809  * g_get_real_name:
1810  *
1811  * Gets the real name of the user. This usually comes from the user's entry 
1812  * in the <filename>passwd</filename> file. The encoding of the returned 
1813  * string is system-defined. (On Windows, it is, however, always UTF-8.) 
1814  * If the real user name cannot be determined, the string "Unknown" is 
1815  * returned.
1816  *
1817  * Returns: the user's real name.
1818  */
1819 G_CONST_RETURN gchar*
1820 g_get_real_name (void)
1821 {
1822   g_get_any_init_locked ();
1823   return g_real_name;
1824 }
1825
1826 /**
1827  * g_get_home_dir:
1828  *
1829  * Gets the current user's home directory as defined in the 
1830  * password database.
1831  *
1832  * Note that in contrast to traditional UNIX tools, this function 
1833  * prefers <filename>passwd</filename> entries over the <envar>HOME</envar> 
1834  * environment variable. 
1835  *
1836  * One of the reasons for this decision is that applications in many 
1837  * cases need special handling to deal with the case where 
1838  * <envar>HOME</envar> is
1839  * <simplelist>
1840  *   <member>Not owned by the user</member>
1841  *   <member>Not writeable</member>
1842  *   <member>Not even readable</member>
1843  * </simplelist>
1844  * Since applications are in general <emphasis>not</emphasis> written 
1845  * to deal with these situations it was considered better to make 
1846  * g_get_home_dir() not pay attention to <envar>HOME</envar> and to 
1847  * return the real home directory for the user. If applications
1848  * want to pay attention to <envar>HOME</envar>, they can do:
1849  * |[
1850  *  const char *homedir = g_getenv ("HOME");
1851  *   if (!homedir)
1852  *      homedir = g_get_home_dir (<!-- -->);
1853  * ]|
1854  *
1855  * Returns: the current user's home directory
1856  */
1857 G_CONST_RETURN gchar*
1858 g_get_home_dir (void)
1859 {
1860   g_get_any_init_locked ();
1861   return g_home_dir;
1862 }
1863
1864 /**
1865  * g_get_tmp_dir:
1866  *
1867  * Gets the directory to use for temporary files. This is found from 
1868  * inspecting the environment variables <envar>TMPDIR</envar>, 
1869  * <envar>TMP</envar>, and <envar>TEMP</envar> in that order. If none 
1870  * of those are defined "/tmp" is returned on UNIX and "C:\" on Windows. 
1871  * The encoding of the returned string is system-defined. On Windows, 
1872  * it is always UTF-8. The return value is never %NULL.
1873  *
1874  * Returns: the directory to use for temporary files.
1875  */
1876 G_CONST_RETURN gchar*
1877 g_get_tmp_dir (void)
1878 {
1879   g_get_any_init_locked ();
1880   return g_tmp_dir;
1881 }
1882
1883 /**
1884  * g_get_host_name:
1885  *
1886  * Return a name for the machine. 
1887  *
1888  * The returned name is not necessarily a fully-qualified domain name,
1889  * or even present in DNS or some other name service at all. It need
1890  * not even be unique on your local network or site, but usually it
1891  * is. Callers should not rely on the return value having any specific
1892  * properties like uniqueness for security purposes. Even if the name
1893  * of the machine is changed while an application is running, the
1894  * return value from this function does not change. The returned
1895  * string is owned by GLib and should not be modified or freed. If no
1896  * name can be determined, a default fixed string "localhost" is
1897  * returned.
1898  *
1899  * Returns: the host name of the machine.
1900  *
1901  * Since: 2.8
1902  */
1903 const gchar *
1904 g_get_host_name (void)
1905 {
1906   g_get_any_init_locked ();
1907   return g_host_name;
1908 }
1909
1910 G_LOCK_DEFINE_STATIC (g_prgname);
1911 static gchar *g_prgname = NULL;
1912
1913 /**
1914  * g_get_prgname:
1915  *
1916  * Gets the name of the program. This name should <emphasis>not</emphasis> 
1917  * be localized, contrast with g_get_application_name().
1918  * (If you are using GDK or GTK+ the program name is set in gdk_init(), 
1919  * which is called by gtk_init(). The program name is found by taking 
1920  * the last component of <literal>argv[0]</literal>.)
1921  *
1922  * Returns: the name of the program. The returned string belongs 
1923  * to GLib and must not be modified or freed.
1924  */
1925 gchar*
1926 g_get_prgname (void)
1927 {
1928   gchar* retval;
1929
1930   G_LOCK (g_prgname);
1931 #ifdef G_OS_WIN32
1932   if (g_prgname == NULL)
1933     {
1934       static gboolean beenhere = FALSE;
1935
1936       if (!beenhere)
1937         {
1938           gchar *utf8_buf = NULL;
1939           wchar_t buf[MAX_PATH+1];
1940
1941           beenhere = TRUE;
1942           if (GetModuleFileNameW (GetModuleHandle (NULL),
1943                                   buf, G_N_ELEMENTS (buf)) > 0)
1944             utf8_buf = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
1945
1946           if (utf8_buf)
1947             {
1948               g_prgname = g_path_get_basename (utf8_buf);
1949               g_free (utf8_buf);
1950             }
1951         }
1952     }
1953 #endif
1954   retval = g_prgname;
1955   G_UNLOCK (g_prgname);
1956
1957   return retval;
1958 }
1959
1960 /**
1961  * g_set_prgname:
1962  * @prgname: the name of the program.
1963  *
1964  * Sets the name of the program. This name should <emphasis>not</emphasis> 
1965  * be localized, contrast with g_set_application_name(). Note that for 
1966  * thread-safety reasons this function can only be called once.
1967  */
1968 void
1969 g_set_prgname (const gchar *prgname)
1970 {
1971   G_LOCK (g_prgname);
1972   g_free (g_prgname);
1973   g_prgname = g_strdup (prgname);
1974   G_UNLOCK (g_prgname);
1975 }
1976
1977 G_LOCK_DEFINE_STATIC (g_application_name);
1978 static gchar *g_application_name = NULL;
1979
1980 /**
1981  * g_get_application_name:
1982  * 
1983  * Gets a human-readable name for the application, as set by
1984  * g_set_application_name(). This name should be localized if
1985  * possible, and is intended for display to the user.  Contrast with
1986  * g_get_prgname(), which gets a non-localized name. If
1987  * g_set_application_name() has not been called, returns the result of
1988  * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
1989  * been called).
1990  * 
1991  * Return value: human-readable application name. may return %NULL
1992  *
1993  * Since: 2.2
1994  **/
1995 G_CONST_RETURN gchar*
1996 g_get_application_name (void)
1997 {
1998   gchar* retval;
1999
2000   G_LOCK (g_application_name);
2001   retval = g_application_name;
2002   G_UNLOCK (g_application_name);
2003
2004   if (retval == NULL)
2005     return g_get_prgname ();
2006   
2007   return retval;
2008 }
2009
2010 /**
2011  * g_set_application_name:
2012  * @application_name: localized name of the application
2013  *
2014  * Sets a human-readable name for the application. This name should be
2015  * localized if possible, and is intended for display to the user.
2016  * Contrast with g_set_prgname(), which sets a non-localized name.
2017  * g_set_prgname() will be called automatically by gtk_init(),
2018  * but g_set_application_name() will not.
2019  *
2020  * Note that for thread safety reasons, this function can only
2021  * be called once.
2022  *
2023  * The application name will be used in contexts such as error messages,
2024  * or when displaying an application's name in the task list.
2025  * 
2026  * Since: 2.2
2027  **/
2028 void
2029 g_set_application_name (const gchar *application_name)
2030 {
2031   gboolean already_set = FALSE;
2032         
2033   G_LOCK (g_application_name);
2034   if (g_application_name)
2035     already_set = TRUE;
2036   else
2037     g_application_name = g_strdup (application_name);
2038   G_UNLOCK (g_application_name);
2039
2040   if (already_set)
2041     g_warning ("g_set_application_name() called multiple times");
2042 }
2043
2044 /**
2045  * g_get_user_data_dir:
2046  * 
2047  * Returns a base directory in which to access application data such
2048  * as icons that is customized for a particular user.  
2049  *
2050  * On UNIX platforms this is determined using the mechanisms described in
2051  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2052  * XDG Base Directory Specification</ulink>
2053  * 
2054  * Return value: a string owned by GLib that must not be modified 
2055  *               or freed.
2056  * Since: 2.6
2057  **/
2058 G_CONST_RETURN gchar*
2059 g_get_user_data_dir (void)
2060 {
2061   gchar *data_dir;  
2062
2063   G_LOCK (g_utils_global);
2064
2065   if (!g_user_data_dir)
2066     {
2067 #ifdef G_OS_WIN32
2068       data_dir = get_special_folder (CSIDL_PERSONAL);
2069 #else
2070       data_dir = (gchar *) g_getenv ("XDG_DATA_HOME");
2071
2072       if (data_dir && data_dir[0])
2073         data_dir = g_strdup (data_dir);
2074 #endif
2075       if (!data_dir || !data_dir[0])
2076         {
2077           g_get_any_init ();
2078
2079           if (g_home_dir)
2080             data_dir = g_build_filename (g_home_dir, ".local", 
2081                                          "share", NULL);
2082           else
2083             data_dir = g_build_filename (g_tmp_dir, g_user_name, ".local", 
2084                                          "share", NULL);
2085         }
2086
2087       g_user_data_dir = data_dir;
2088     }
2089   else
2090     data_dir = g_user_data_dir;
2091
2092   G_UNLOCK (g_utils_global);
2093
2094   return data_dir;
2095 }
2096
2097 static void
2098 g_init_user_config_dir (void)
2099 {
2100   gchar *config_dir;
2101
2102   if (!g_user_config_dir)
2103     {
2104 #ifdef G_OS_WIN32
2105       config_dir = get_special_folder (CSIDL_APPDATA);
2106 #else
2107       config_dir = (gchar *) g_getenv ("XDG_CONFIG_HOME");
2108
2109       if (config_dir && config_dir[0])
2110         config_dir = g_strdup (config_dir);
2111 #endif
2112       if (!config_dir || !config_dir[0])
2113         {
2114           g_get_any_init ();
2115
2116           if (g_home_dir)
2117             config_dir = g_build_filename (g_home_dir, ".config", NULL);
2118           else
2119             config_dir = g_build_filename (g_tmp_dir, g_user_name, ".config", NULL);
2120         }
2121
2122       g_user_config_dir = config_dir;
2123     }
2124 }
2125
2126 /**
2127  * g_get_user_config_dir:
2128  * 
2129  * Returns a base directory in which to store user-specific application 
2130  * configuration information such as user preferences and settings. 
2131  *
2132  * On UNIX platforms this is determined using the mechanisms described in
2133  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2134  * XDG Base Directory Specification</ulink>.
2135  * In this case the directory retrieved will be XDG_CONFIG_HOME.
2136  *
2137  * On Windows is the directory that serves as a common repository for
2138  * application-specific data. A typical path is
2139  * C:\Documents and Settings\username\Application. See documentation for
2140  * CSIDL_APPDATA.
2141  *
2142  * Return value: a string owned by GLib that must not be modified 
2143  *               or freed.
2144  * Since: 2.6
2145  **/
2146 G_CONST_RETURN gchar*
2147 g_get_user_config_dir (void)
2148 {
2149   G_LOCK (g_utils_global);
2150
2151   g_init_user_config_dir ();
2152
2153   G_UNLOCK (g_utils_global);
2154
2155   return g_user_config_dir;
2156 }
2157
2158 /**
2159  * g_get_user_cache_dir:
2160  * 
2161  * Returns a base directory in which to store non-essential, cached
2162  * data specific to particular user.
2163  *
2164  * On UNIX platforms this is determined using the mechanisms described in
2165  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2166  * XDG Base Directory Specification</ulink>
2167  * 
2168  * Return value: a string owned by GLib that must not be modified 
2169  *               or freed.
2170  * Since: 2.6
2171  **/
2172 G_CONST_RETURN gchar*
2173 g_get_user_cache_dir (void)
2174 {
2175   gchar *cache_dir;  
2176
2177   G_LOCK (g_utils_global);
2178
2179   if (!g_user_cache_dir)
2180     {
2181 #ifdef G_OS_WIN32
2182       cache_dir = get_special_folder (CSIDL_INTERNET_CACHE); /* XXX correct? */
2183 #else
2184       cache_dir = (gchar *) g_getenv ("XDG_CACHE_HOME");
2185
2186       if (cache_dir && cache_dir[0])
2187           cache_dir = g_strdup (cache_dir);
2188 #endif
2189       if (!cache_dir || !cache_dir[0])
2190         {
2191           g_get_any_init ();
2192         
2193           if (g_home_dir)
2194             cache_dir = g_build_filename (g_home_dir, ".cache", NULL);
2195           else
2196             cache_dir = g_build_filename (g_tmp_dir, g_user_name, ".cache", NULL);
2197         }
2198       g_user_cache_dir = cache_dir;
2199     }
2200   else
2201     cache_dir = g_user_cache_dir;
2202
2203   G_UNLOCK (g_utils_global);
2204
2205   return cache_dir;
2206 }
2207
2208 #ifdef HAVE_CARBON
2209
2210 static gchar *
2211 find_folder (OSType type)
2212 {
2213   gchar *filename = NULL;
2214   FSRef  found;
2215
2216   if (FSFindFolder (kUserDomain, type, kDontCreateFolder, &found) == noErr)
2217     {
2218       CFURLRef url = CFURLCreateFromFSRef (kCFAllocatorSystemDefault, &found);
2219
2220       if (url)
2221         {
2222           CFStringRef path = CFURLCopyFileSystemPath (url, kCFURLPOSIXPathStyle);
2223
2224           if (path)
2225             {
2226               filename = g_strdup (CFStringGetCStringPtr (path, kCFStringEncodingUTF8));
2227
2228               if (! filename)
2229                 {
2230                   filename = g_new0 (gchar, CFStringGetLength (path) * 3 + 1);
2231
2232                   CFStringGetCString (path, filename,
2233                                       CFStringGetLength (path) * 3 + 1,
2234                                       kCFStringEncodingUTF8);
2235                 }
2236
2237               CFRelease (path);
2238             }
2239
2240           CFRelease (url);
2241         }
2242     }
2243
2244   return filename;
2245 }
2246
2247 static void
2248 load_user_special_dirs (void)
2249 {
2250   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = find_folder (kDesktopFolderType);
2251   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = find_folder (kDocumentsFolderType);
2252   g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = find_folder (kDesktopFolderType); /* XXX correct ? */
2253   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = find_folder (kMusicDocumentsFolderType);
2254   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = find_folder (kPictureDocumentsFolderType);
2255   g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = NULL;
2256   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = NULL;
2257   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = find_folder (kMovieDocumentsFolderType);
2258 }
2259
2260 #endif /* HAVE_CARBON */
2261
2262 #if defined(G_OS_WIN32)
2263 static void
2264 load_user_special_dirs (void)
2265 {
2266   typedef HRESULT (WINAPI *t_SHGetKnownFolderPath) (const GUID *rfid,
2267                                                     DWORD dwFlags,
2268                                                     HANDLE hToken,
2269                                                     PWSTR *ppszPath);
2270   t_SHGetKnownFolderPath p_SHGetKnownFolderPath;
2271   static const GUID FOLDERID_Downloads =
2272     { 0x374de290, 0x123f, 0x4565, { 0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b } };
2273   static const GUID FOLDERID_Public =
2274     { 0xDFDF76A2, 0xC82A, 0x4D63, { 0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85 } };
2275   wchar_t *wcp;
2276
2277   p_SHGetKnownFolderPath = (t_SHGetKnownFolderPath) GetProcAddress (LoadLibrary ("shell32.dll"),
2278                                                                     "SHGetKnownFolderPath");
2279
2280   g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2281   g_user_special_dirs[G_USER_DIRECTORY_DOCUMENTS] = get_special_folder (CSIDL_PERSONAL);
2282
2283   if (p_SHGetKnownFolderPath == NULL)
2284     {
2285       g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2286     }
2287   else
2288     {
2289       wcp = NULL;
2290       (*p_SHGetKnownFolderPath) (&FOLDERID_Downloads, 0, NULL, &wcp);
2291       g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
2292       if (g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] == NULL)
2293         g_user_special_dirs[G_USER_DIRECTORY_DOWNLOAD] = get_special_folder (CSIDL_DESKTOPDIRECTORY);
2294       CoTaskMemFree (wcp);
2295     }
2296
2297   g_user_special_dirs[G_USER_DIRECTORY_MUSIC] = get_special_folder (CSIDL_MYMUSIC);
2298   g_user_special_dirs[G_USER_DIRECTORY_PICTURES] = get_special_folder (CSIDL_MYPICTURES);
2299
2300   if (p_SHGetKnownFolderPath == NULL)
2301     {
2302       /* XXX */
2303       g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2304     }
2305   else
2306     {
2307       wcp = NULL;
2308       (*p_SHGetKnownFolderPath) (&FOLDERID_Public, 0, NULL, &wcp);
2309       g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = g_utf16_to_utf8 (wcp, -1, NULL, NULL, NULL);
2310       if (g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] == NULL)
2311         g_user_special_dirs[G_USER_DIRECTORY_PUBLIC_SHARE] = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2312       CoTaskMemFree (wcp);
2313     }
2314   
2315   g_user_special_dirs[G_USER_DIRECTORY_TEMPLATES] = get_special_folder (CSIDL_TEMPLATES);
2316   g_user_special_dirs[G_USER_DIRECTORY_VIDEOS] = get_special_folder (CSIDL_MYVIDEO);
2317 }
2318 #endif /* G_OS_WIN32 */
2319
2320 static void g_init_user_config_dir (void);
2321
2322 #if defined(G_OS_UNIX) && !defined(HAVE_CARBON)
2323
2324 /* adapted from xdg-user-dir-lookup.c
2325  *
2326  * Copyright (C) 2007 Red Hat Inc.
2327  *
2328  * Permission is hereby granted, free of charge, to any person
2329  * obtaining a copy of this software and associated documentation files
2330  * (the "Software"), to deal in the Software without restriction,
2331  * including without limitation the rights to use, copy, modify, merge,
2332  * publish, distribute, sublicense, and/or sell copies of the Software,
2333  * and to permit persons to whom the Software is furnished to do so,
2334  * subject to the following conditions: 
2335  *
2336  * The above copyright notice and this permission notice shall be
2337  * included in all copies or substantial portions of the Software. 
2338  *
2339  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
2340  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2341  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
2342  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
2343  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
2344  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
2345  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
2346  * SOFTWARE.
2347  */
2348 static void
2349 load_user_special_dirs (void)
2350 {
2351   gchar *config_file;
2352   gchar *data;
2353   gchar **lines;
2354   gint n_lines, i;
2355   
2356   g_init_user_config_dir ();
2357   config_file = g_build_filename (g_user_config_dir,
2358                                   "user-dirs.dirs",
2359                                   NULL);
2360   
2361   if (!g_file_get_contents (config_file, &data, NULL, NULL))
2362     {
2363       g_free (config_file);
2364       return;
2365     }
2366
2367   lines = g_strsplit (data, "\n", -1);
2368   n_lines = g_strv_length (lines);
2369   g_free (data);
2370   
2371   for (i = 0; i < n_lines; i++)
2372     {
2373       gchar *buffer = lines[i];
2374       gchar *d, *p;
2375       gint len;
2376       gboolean is_relative = FALSE;
2377       GUserDirectory directory;
2378
2379       /* Remove newline at end */
2380       len = strlen (buffer);
2381       if (len > 0 && buffer[len - 1] == '\n')
2382         buffer[len - 1] = 0;
2383       
2384       p = buffer;
2385       while (*p == ' ' || *p == '\t')
2386         p++;
2387       
2388       if (strncmp (p, "XDG_DESKTOP_DIR", strlen ("XDG_DESKTOP_DIR")) == 0)
2389         {
2390           directory = G_USER_DIRECTORY_DESKTOP;
2391           p += strlen ("XDG_DESKTOP_DIR");
2392         }
2393       else if (strncmp (p, "XDG_DOCUMENTS_DIR", strlen ("XDG_DOCUMENTS_DIR")) == 0)
2394         {
2395           directory = G_USER_DIRECTORY_DOCUMENTS;
2396           p += strlen ("XDG_DOCUMENTS_DIR");
2397         }
2398       else if (strncmp (p, "XDG_DOWNLOAD_DIR", strlen ("XDG_DOWNLOAD_DIR")) == 0)
2399         {
2400           directory = G_USER_DIRECTORY_DOWNLOAD;
2401           p += strlen ("XDG_DOWNLOAD_DIR");
2402         }
2403       else if (strncmp (p, "XDG_MUSIC_DIR", strlen ("XDG_MUSIC_DIR")) == 0)
2404         {
2405           directory = G_USER_DIRECTORY_MUSIC;
2406           p += strlen ("XDG_MUSIC_DIR");
2407         }
2408       else if (strncmp (p, "XDG_PICTURES_DIR", strlen ("XDG_PICTURES_DIR")) == 0)
2409         {
2410           directory = G_USER_DIRECTORY_PICTURES;
2411           p += strlen ("XDG_PICTURES_DIR");
2412         }
2413       else if (strncmp (p, "XDG_PUBLICSHARE_DIR", strlen ("XDG_PUBLICSHARE_DIR")) == 0)
2414         {
2415           directory = G_USER_DIRECTORY_PUBLIC_SHARE;
2416           p += strlen ("XDG_PUBLICSHARE_DIR");
2417         }
2418       else if (strncmp (p, "XDG_TEMPLATES_DIR", strlen ("XDG_TEMPLATES_DIR")) == 0)
2419         {
2420           directory = G_USER_DIRECTORY_TEMPLATES;
2421           p += strlen ("XDG_TEMPLATES_DIR");
2422         }
2423       else if (strncmp (p, "XDG_VIDEOS_DIR", strlen ("XDG_VIDEOS_DIR")) == 0)
2424         {
2425           directory = G_USER_DIRECTORY_VIDEOS;
2426           p += strlen ("XDG_VIDEOS_DIR");
2427         }
2428       else
2429         continue;
2430
2431       while (*p == ' ' || *p == '\t')
2432         p++;
2433
2434       if (*p != '=')
2435         continue;
2436       p++;
2437
2438       while (*p == ' ' || *p == '\t')
2439         p++;
2440
2441       if (*p != '"')
2442         continue;
2443       p++;
2444
2445       if (strncmp (p, "$HOME", 5) == 0)
2446         {
2447           p += 5;
2448           is_relative = TRUE;
2449         }
2450       else if (*p != '/')
2451         continue;
2452
2453       d = strrchr (p, '"');
2454       if (!d)
2455         continue;
2456       *d = 0;
2457
2458       d = p;
2459       
2460       /* remove trailing slashes */
2461       len = strlen (d);
2462       if (d[len - 1] == '/')
2463         d[len - 1] = 0;
2464       
2465       if (is_relative)
2466         {
2467           g_get_any_init ();
2468           g_user_special_dirs[directory] = g_build_filename (g_home_dir, d, NULL);
2469         }
2470       else
2471         g_user_special_dirs[directory] = g_strdup (d);
2472     }
2473
2474   g_strfreev (lines);
2475   g_free (config_file);
2476 }
2477
2478 #endif /* G_OS_UNIX && !HAVE_CARBON */
2479
2480
2481 /**
2482  * g_reload_user_special_dirs_cache:
2483  *
2484  * Resets the cache used for g_get_user_special_dir(), so
2485  * that the latest on-disk version is used. Call this only
2486  * if you just changed the data on disk yourself.
2487  *
2488  * Due to threadsafety issues this may cause leaking of strings
2489  * that were previously returned from g_get_user_special_dir()
2490  * that can't be freed. We ensure to only leak the data for
2491  * the directories that actually changed value though.
2492  *
2493  * Since: 2.22
2494  */
2495 void
2496 g_reload_user_special_dirs_cache (void)
2497 {
2498   int i;
2499
2500   G_LOCK (g_utils_global);
2501
2502   if (g_user_special_dirs != NULL)
2503     {
2504       /* save a copy of the pointer, to check if some memory can be preserved */
2505       char **old_g_user_special_dirs = g_user_special_dirs;
2506       char *old_val;
2507
2508       /* recreate and reload our cache */
2509       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
2510       load_user_special_dirs ();
2511
2512       /* only leak changed directories */
2513       for (i = 0; i < G_USER_N_DIRECTORIES; i++)
2514         {
2515           old_val = old_g_user_special_dirs[i];
2516           if (g_strcmp0 (old_val, g_user_special_dirs[i]) == 0)
2517             {
2518               /* don't leak */
2519               g_free (g_user_special_dirs[i]);
2520               g_user_special_dirs[i] = old_val;
2521             }
2522           else
2523             g_free (old_val);
2524         }
2525
2526       /* free the old array */
2527       g_free (old_g_user_special_dirs);
2528     }
2529
2530   G_UNLOCK (g_utils_global);
2531 }
2532
2533 /**
2534  * g_get_user_special_dir:
2535  * @directory: the logical id of special directory
2536  *
2537  * Returns the full path of a special directory using its logical id.
2538  *
2539  * On Unix this is done using the XDG special user directories.
2540  * For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
2541  * falls back to <filename>$HOME/Desktop</filename> when XDG special
2542  * user directories have not been set up. 
2543  *
2544  * Depending on the platform, the user might be able to change the path
2545  * of the special directory without requiring the session to restart; GLib
2546  * will not reflect any change once the special directories are loaded.
2547  *
2548  * Return value: the path to the specified special directory, or %NULL
2549  *   if the logical id was not found. The returned string is owned by
2550  *   GLib and should not be modified or freed.
2551  *
2552  * Since: 2.14
2553  */
2554 G_CONST_RETURN gchar *
2555 g_get_user_special_dir (GUserDirectory directory)
2556 {
2557   g_return_val_if_fail (directory >= G_USER_DIRECTORY_DESKTOP &&
2558                         directory < G_USER_N_DIRECTORIES, NULL);
2559
2560   G_LOCK (g_utils_global);
2561
2562   if (G_UNLIKELY (g_user_special_dirs == NULL))
2563     {
2564       g_user_special_dirs = g_new0 (gchar *, G_USER_N_DIRECTORIES);
2565
2566       load_user_special_dirs ();
2567
2568       /* Special-case desktop for historical compatibility */
2569       if (g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] == NULL)
2570         {
2571           g_get_any_init ();
2572
2573           g_user_special_dirs[G_USER_DIRECTORY_DESKTOP] =
2574             g_build_filename (g_home_dir, "Desktop", NULL);
2575         }
2576     }
2577
2578   G_UNLOCK (g_utils_global);
2579
2580   return g_user_special_dirs[directory];
2581 }
2582
2583 #ifdef G_OS_WIN32
2584
2585 #undef g_get_system_data_dirs
2586
2587 static HMODULE
2588 get_module_for_address (gconstpointer address)
2589 {
2590   /* Holds the g_utils_global lock */
2591
2592   static gboolean beenhere = FALSE;
2593   typedef BOOL (WINAPI *t_GetModuleHandleExA) (DWORD, LPCTSTR, HMODULE *);
2594   static t_GetModuleHandleExA p_GetModuleHandleExA = NULL;
2595   HMODULE hmodule = NULL;
2596
2597   if (!address)
2598     return NULL;
2599
2600   if (!beenhere)
2601     {
2602       p_GetModuleHandleExA =
2603         (t_GetModuleHandleExA) GetProcAddress (LoadLibrary ("kernel32.dll"),
2604                                                "GetModuleHandleExA");
2605       beenhere = TRUE;
2606     }
2607
2608   if (p_GetModuleHandleExA == NULL ||
2609       !(*p_GetModuleHandleExA) (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
2610                                 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
2611                                 address, &hmodule))
2612     {
2613       MEMORY_BASIC_INFORMATION mbi;
2614       VirtualQuery (address, &mbi, sizeof (mbi));
2615       hmodule = (HMODULE) mbi.AllocationBase;
2616     }
2617
2618   return hmodule;
2619 }
2620
2621 static gchar *
2622 get_module_share_dir (gconstpointer address)
2623 {
2624   HMODULE hmodule;
2625   gchar *filename;
2626   gchar *retval;
2627
2628   hmodule = get_module_for_address (address);
2629   if (hmodule == NULL)
2630     return NULL;
2631
2632   filename = g_win32_get_package_installation_directory_of_module (hmodule);
2633   retval = g_build_filename (filename, "share", NULL);
2634   g_free (filename);
2635
2636   return retval;
2637 }
2638
2639 G_CONST_RETURN gchar * G_CONST_RETURN *
2640 g_win32_get_system_data_dirs_for_module (void (*address_of_function)())
2641 {
2642   GArray *data_dirs;
2643   HMODULE hmodule;
2644   static GHashTable *per_module_data_dirs = NULL;
2645   gchar **retval;
2646   gchar *p;
2647   gchar *exe_root;
2648       
2649   if (address_of_function)
2650     {
2651       G_LOCK (g_utils_global);
2652       hmodule = get_module_for_address (address_of_function);
2653       if (hmodule != NULL)
2654         {
2655           if (per_module_data_dirs == NULL)
2656             per_module_data_dirs = g_hash_table_new (NULL, NULL);
2657           else
2658             {
2659               retval = g_hash_table_lookup (per_module_data_dirs, hmodule);
2660               
2661               if (retval != NULL)
2662                 {
2663                   G_UNLOCK (g_utils_global);
2664                   return (G_CONST_RETURN gchar * G_CONST_RETURN *) retval;
2665                 }
2666             }
2667         }
2668     }
2669
2670   data_dirs = g_array_new (TRUE, TRUE, sizeof (char *));
2671
2672   /* Documents and Settings\All Users\Application Data */
2673   p = get_special_folder (CSIDL_COMMON_APPDATA);
2674   if (p)
2675     g_array_append_val (data_dirs, p);
2676   
2677   /* Documents and Settings\All Users\Documents */
2678   p = get_special_folder (CSIDL_COMMON_DOCUMENTS);
2679   if (p)
2680     g_array_append_val (data_dirs, p);
2681         
2682   /* Using the above subfolders of Documents and Settings perhaps
2683    * makes sense from a Windows perspective.
2684    *
2685    * But looking at the actual use cases of this function in GTK+
2686    * and GNOME software, what we really want is the "share"
2687    * subdirectory of the installation directory for the package
2688    * our caller is a part of.
2689    *
2690    * The address_of_function parameter, if non-NULL, points to a
2691    * function in the calling module. Use that to determine that
2692    * module's installation folder, and use its "share" subfolder.
2693    *
2694    * Additionally, also use the "share" subfolder of the installation
2695    * locations of GLib and the .exe file being run.
2696    *
2697    * To guard against none of the above being what is really wanted,
2698    * callers of this function should have Win32-specific code to look
2699    * up their installation folder themselves, and handle a subfolder
2700    * "share" of it in the same way as the folders returned from this
2701    * function.
2702    */
2703
2704   p = get_module_share_dir (address_of_function);
2705   if (p)
2706     g_array_append_val (data_dirs, p);
2707     
2708   if (glib_dll != NULL)
2709     {
2710       gchar *glib_root = g_win32_get_package_installation_directory_of_module (glib_dll);
2711       p = g_build_filename (glib_root, "share", NULL);
2712       if (p)
2713         g_array_append_val (data_dirs, p);
2714       g_free (glib_root);
2715     }
2716   
2717   exe_root = g_win32_get_package_installation_directory_of_module (NULL);
2718   p = g_build_filename (exe_root, "share", NULL);
2719   if (p)
2720     g_array_append_val (data_dirs, p);
2721   g_free (exe_root);
2722
2723   retval = (gchar **) g_array_free (data_dirs, FALSE);
2724
2725   if (address_of_function)
2726     {
2727       if (hmodule != NULL)
2728         g_hash_table_insert (per_module_data_dirs, hmodule, retval);
2729       G_UNLOCK (g_utils_global);
2730     }
2731
2732   return (G_CONST_RETURN gchar * G_CONST_RETURN *) retval;
2733 }
2734
2735 #endif
2736
2737 /**
2738  * g_get_system_data_dirs:
2739  * 
2740  * Returns an ordered list of base directories in which to access 
2741  * system-wide application data.
2742  *
2743  * On UNIX platforms this is determined using the mechanisms described in
2744  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2745  * XDG Base Directory Specification</ulink>
2746  * 
2747  * On Windows the first elements in the list are the Application Data
2748  * and Documents folders for All Users. (These can be determined only
2749  * on Windows 2000 or later and are not present in the list on other
2750  * Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
2751  * CSIDL_COMMON_DOCUMENTS.
2752  *
2753  * Then follows the "share" subfolder in the installation folder for
2754  * the package containing the DLL that calls this function, if it can
2755  * be determined.
2756  * 
2757  * Finally the list contains the "share" subfolder in the installation
2758  * folder for GLib, and in the installation folder for the package the
2759  * application's .exe file belongs to.
2760  *
2761  * The installation folders above are determined by looking up the
2762  * folder where the module (DLL or EXE) in question is located. If the
2763  * folder's name is "bin", its parent is used, otherwise the folder
2764  * itself.
2765  *
2766  * Note that on Windows the returned list can vary depending on where
2767  * this function is called.
2768  *
2769  * Return value: a %NULL-terminated array of strings owned by GLib that must 
2770  *               not be modified or freed.
2771  * Since: 2.6
2772  **/
2773 G_CONST_RETURN gchar * G_CONST_RETURN * 
2774 g_get_system_data_dirs (void)
2775 {
2776   gchar **data_dir_vector;
2777
2778   G_LOCK (g_utils_global);
2779
2780   if (!g_system_data_dirs)
2781     {
2782 #ifdef G_OS_WIN32
2783       data_dir_vector = (gchar **) g_win32_get_system_data_dirs_for_module (NULL);
2784 #else
2785       gchar *data_dirs = (gchar *) g_getenv ("XDG_DATA_DIRS");
2786
2787       if (!data_dirs || !data_dirs[0])
2788           data_dirs = "/usr/local/share/:/usr/share/";
2789
2790       data_dir_vector = g_strsplit (data_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2791 #endif
2792
2793       g_system_data_dirs = data_dir_vector;
2794     }
2795   else
2796     data_dir_vector = g_system_data_dirs;
2797
2798   G_UNLOCK (g_utils_global);
2799
2800   return (G_CONST_RETURN gchar * G_CONST_RETURN *) data_dir_vector;
2801 }
2802
2803 /**
2804  * g_get_system_config_dirs:
2805  * 
2806  * Returns an ordered list of base directories in which to access 
2807  * system-wide configuration information.
2808  *
2809  * On UNIX platforms this is determined using the mechanisms described in
2810  * the <ulink url="http://www.freedesktop.org/Standards/basedir-spec">
2811  * XDG Base Directory Specification</ulink>
2812  * 
2813  * Return value: a %NULL-terminated array of strings owned by GLib that must 
2814  *               not be modified or freed.
2815  * Since: 2.6
2816  **/
2817 G_CONST_RETURN gchar * G_CONST_RETURN *
2818 g_get_system_config_dirs (void)
2819 {
2820   gchar *conf_dirs, **conf_dir_vector;
2821
2822   G_LOCK (g_utils_global);
2823
2824   if (!g_system_config_dirs)
2825     {
2826 #ifdef G_OS_WIN32
2827       conf_dirs = get_special_folder (CSIDL_COMMON_APPDATA);
2828       if (conf_dirs)
2829         {
2830           conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2831           g_free (conf_dirs);
2832         }
2833       else
2834         {
2835           /* Return empty list */
2836           conf_dir_vector = g_strsplit ("", G_SEARCHPATH_SEPARATOR_S, 0);
2837         }
2838 #else
2839       conf_dirs = (gchar *) g_getenv ("XDG_CONFIG_DIRS");
2840
2841       if (!conf_dirs || !conf_dirs[0])
2842           conf_dirs = "/etc/xdg";
2843
2844       conf_dir_vector = g_strsplit (conf_dirs, G_SEARCHPATH_SEPARATOR_S, 0);
2845 #endif
2846
2847       g_system_config_dirs = conf_dir_vector;
2848     }
2849   else
2850     conf_dir_vector = g_system_config_dirs;
2851   G_UNLOCK (g_utils_global);
2852
2853   return (G_CONST_RETURN gchar * G_CONST_RETURN *) conf_dir_vector;
2854 }
2855
2856 #ifndef G_OS_WIN32
2857
2858 static GHashTable *alias_table = NULL;
2859
2860 /* read an alias file for the locales */
2861 static void
2862 read_aliases (gchar *file)
2863 {
2864   FILE *fp;
2865   char buf[256];
2866   
2867   if (!alias_table)
2868     alias_table = g_hash_table_new (g_str_hash, g_str_equal);
2869   fp = fopen (file,"r");
2870   if (!fp)
2871     return;
2872   while (fgets (buf, 256, fp))
2873     {
2874       char *p, *q;
2875
2876       g_strstrip (buf);
2877
2878       /* Line is a comment */
2879       if ((buf[0] == '#') || (buf[0] == '\0'))
2880         continue;
2881
2882       /* Reads first column */
2883       for (p = buf, q = NULL; *p; p++) {
2884         if ((*p == '\t') || (*p == ' ') || (*p == ':')) {
2885           *p = '\0';
2886           q = p+1;
2887           while ((*q == '\t') || (*q == ' ')) {
2888             q++;
2889           }
2890           break;
2891         }
2892       }
2893       /* The line only had one column */
2894       if (!q || *q == '\0')
2895         continue;
2896       
2897       /* Read second column */
2898       for (p = q; *p; p++) {
2899         if ((*p == '\t') || (*p == ' ')) {
2900           *p = '\0';
2901           break;
2902         }
2903       }
2904
2905       /* Add to alias table if necessary */
2906       if (!g_hash_table_lookup (alias_table, buf)) {
2907         g_hash_table_insert (alias_table, g_strdup (buf), g_strdup (q));
2908       }
2909     }
2910   fclose (fp);
2911 }
2912
2913 #endif
2914
2915 static char *
2916 unalias_lang (char *lang)
2917 {
2918 #ifndef G_OS_WIN32
2919   char *p;
2920   int i;
2921
2922   if (!alias_table)
2923     read_aliases ("/usr/share/locale/locale.alias");
2924
2925   i = 0;
2926   while ((p = g_hash_table_lookup (alias_table, lang)) && (strcmp (p, lang) != 0))
2927     {
2928       lang = p;
2929       if (i++ == 30)
2930         {
2931           static gboolean said_before = FALSE;
2932           if (!said_before)
2933             g_warning ("Too many alias levels for a locale, "
2934                        "may indicate a loop");
2935           said_before = TRUE;
2936           return lang;
2937         }
2938     }
2939 #endif
2940   return lang;
2941 }
2942
2943 /* Mask for components of locale spec. The ordering here is from
2944  * least significant to most significant
2945  */
2946 enum
2947 {
2948   COMPONENT_CODESET =   1 << 0,
2949   COMPONENT_TERRITORY = 1 << 1,
2950   COMPONENT_MODIFIER =  1 << 2
2951 };
2952
2953 /* Break an X/Open style locale specification into components
2954  */
2955 static guint
2956 explode_locale (const gchar *locale,
2957                 gchar      **language, 
2958                 gchar      **territory, 
2959                 gchar      **codeset, 
2960                 gchar      **modifier)
2961 {
2962   const gchar *uscore_pos;
2963   const gchar *at_pos;
2964   const gchar *dot_pos;
2965
2966   guint mask = 0;
2967
2968   uscore_pos = strchr (locale, '_');
2969   dot_pos = strchr (uscore_pos ? uscore_pos : locale, '.');
2970   at_pos = strchr (dot_pos ? dot_pos : (uscore_pos ? uscore_pos : locale), '@');
2971
2972   if (at_pos)
2973     {
2974       mask |= COMPONENT_MODIFIER;
2975       *modifier = g_strdup (at_pos);
2976     }
2977   else
2978     at_pos = locale + strlen (locale);
2979
2980   if (dot_pos)
2981     {
2982       mask |= COMPONENT_CODESET;
2983       *codeset = g_strndup (dot_pos, at_pos - dot_pos);
2984     }
2985   else
2986     dot_pos = at_pos;
2987
2988   if (uscore_pos)
2989     {
2990       mask |= COMPONENT_TERRITORY;
2991       *territory = g_strndup (uscore_pos, dot_pos - uscore_pos);
2992     }
2993   else
2994     uscore_pos = dot_pos;
2995
2996   *language = g_strndup (locale, uscore_pos - locale);
2997
2998   return mask;
2999 }
3000
3001 /*
3002  * Compute all interesting variants for a given locale name -
3003  * by stripping off different components of the value.
3004  *
3005  * For simplicity, we assume that the locale is in
3006  * X/Open format: language[_territory][.codeset][@modifier]
3007  *
3008  * TODO: Extend this to handle the CEN format (see the GNUlibc docs)
3009  *       as well. We could just copy the code from glibc wholesale
3010  *       but it is big, ugly, and complicated, so I'm reluctant
3011  *       to do so when this should handle 99% of the time...
3012  */
3013 GSList *
3014 _g_compute_locale_variants (const gchar *locale)
3015 {
3016   GSList *retval = NULL;
3017
3018   gchar *language = NULL;
3019   gchar *territory = NULL;
3020   gchar *codeset = NULL;
3021   gchar *modifier = NULL;
3022
3023   guint mask;
3024   guint i;
3025
3026   g_return_val_if_fail (locale != NULL, NULL);
3027
3028   mask = explode_locale (locale, &language, &territory, &codeset, &modifier);
3029
3030   /* Iterate through all possible combinations, from least attractive
3031    * to most attractive.
3032    */
3033   for (i = 0; i <= mask; i++)
3034     if ((i & ~mask) == 0)
3035       {
3036         gchar *val = g_strconcat (language,
3037                                   (i & COMPONENT_TERRITORY) ? territory : "",
3038                                   (i & COMPONENT_CODESET) ? codeset : "",
3039                                   (i & COMPONENT_MODIFIER) ? modifier : "",
3040                                   NULL);
3041         retval = g_slist_prepend (retval, val);
3042       }
3043
3044   g_free (language);
3045   if (mask & COMPONENT_CODESET)
3046     g_free (codeset);
3047   if (mask & COMPONENT_TERRITORY)
3048     g_free (territory);
3049   if (mask & COMPONENT_MODIFIER)
3050     g_free (modifier);
3051
3052   return retval;
3053 }
3054
3055 /* The following is (partly) taken from the gettext package.
3056    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.  */
3057
3058 static const gchar *
3059 guess_category_value (const gchar *category_name)
3060 {
3061   const gchar *retval;
3062
3063   /* The highest priority value is the `LANGUAGE' environment
3064      variable.  This is a GNU extension.  */
3065   retval = g_getenv ("LANGUAGE");
3066   if ((retval != NULL) && (retval[0] != '\0'))
3067     return retval;
3068
3069   /* `LANGUAGE' is not set.  So we have to proceed with the POSIX
3070      methods of looking to `LC_ALL', `LC_xxx', and `LANG'.  On some
3071      systems this can be done by the `setlocale' function itself.  */
3072
3073   /* Setting of LC_ALL overwrites all other.  */
3074   retval = g_getenv ("LC_ALL");  
3075   if ((retval != NULL) && (retval[0] != '\0'))
3076     return retval;
3077
3078   /* Next comes the name of the desired category.  */
3079   retval = g_getenv (category_name);
3080   if ((retval != NULL) && (retval[0] != '\0'))
3081     return retval;
3082
3083   /* Last possibility is the LANG environment variable.  */
3084   retval = g_getenv ("LANG");
3085   if ((retval != NULL) && (retval[0] != '\0'))
3086     return retval;
3087
3088 #ifdef G_PLATFORM_WIN32
3089   /* g_win32_getlocale() first checks for LC_ALL, LC_MESSAGES and
3090    * LANG, which we already did above. Oh well. The main point of
3091    * calling g_win32_getlocale() is to get the thread's locale as used
3092    * by Windows and the Microsoft C runtime (in the "English_United
3093    * States" format) translated into the Unixish format.
3094    */
3095   retval = g_win32_getlocale ();
3096   if ((retval != NULL) && (retval[0] != '\0'))
3097     return retval;
3098 #endif  
3099
3100   return NULL;
3101 }
3102
3103 typedef struct _GLanguageNamesCache GLanguageNamesCache;
3104
3105 struct _GLanguageNamesCache {
3106   gchar *languages;
3107   gchar **language_names;
3108 };
3109
3110 static void
3111 language_names_cache_free (gpointer data)
3112 {
3113   GLanguageNamesCache *cache = data;
3114   g_free (cache->languages);
3115   g_strfreev (cache->language_names);
3116   g_free (cache);
3117 }
3118
3119 /**
3120  * g_get_language_names:
3121  * 
3122  * Computes a list of applicable locale names, which can be used to 
3123  * e.g. construct locale-dependent filenames or search paths. The returned 
3124  * list is sorted from most desirable to least desirable and always contains 
3125  * the default locale "C".
3126  *
3127  * For example, if LANGUAGE=de:en_US, then the returned list is
3128  * "de", "en_US", "en", "C".
3129  *
3130  * This function consults the environment variables <envar>LANGUAGE</envar>, 
3131  * <envar>LC_ALL</envar>, <envar>LC_MESSAGES</envar> and <envar>LANG</envar> 
3132  * to find the list of locales specified by the user.
3133  * 
3134  * Return value: a %NULL-terminated array of strings owned by GLib 
3135  *    that must not be modified or freed.
3136  *
3137  * Since: 2.6
3138  **/
3139 G_CONST_RETURN gchar * G_CONST_RETURN * 
3140 g_get_language_names (void)
3141 {
3142   static GStaticPrivate cache_private = G_STATIC_PRIVATE_INIT;
3143   GLanguageNamesCache *cache = g_static_private_get (&cache_private);
3144   const gchar *value;
3145
3146   if (!cache)
3147     {
3148       cache = g_new0 (GLanguageNamesCache, 1);
3149       g_static_private_set (&cache_private, cache, language_names_cache_free);
3150     }
3151
3152   value = guess_category_value ("LC_MESSAGES");
3153   if (!value)
3154     value = "C";
3155
3156   if (!(cache->languages && strcmp (cache->languages, value) == 0))
3157     {
3158       gchar **languages;
3159       gchar **alist, **a;
3160       GSList *list, *l;
3161       gint i;
3162
3163       g_free (cache->languages);
3164       g_strfreev (cache->language_names);
3165       cache->languages = g_strdup (value);
3166
3167       alist = g_strsplit (value, ":", 0);
3168       list = NULL;
3169       for (a = alist; *a; a++)
3170         {
3171           gchar *b = unalias_lang (*a);
3172           list = g_slist_concat (list, _g_compute_locale_variants (b));
3173         }
3174       g_strfreev (alist);
3175       list = g_slist_append (list, g_strdup ("C"));
3176
3177       cache->language_names = languages = g_new (gchar *, g_slist_length (list) + 1);
3178       for (l = list, i = 0; l; l = l->next, i++)
3179         languages[i] = l->data;
3180       languages[i] = NULL;
3181
3182       g_slist_free (list);
3183     }
3184
3185   return (G_CONST_RETURN gchar * G_CONST_RETURN *) cache->language_names;
3186 }
3187
3188 /**
3189  * g_direct_hash:
3190  * @v: a #gpointer key
3191  *
3192  * Converts a gpointer to a hash value.
3193  * It can be passed to g_hash_table_new() as the @hash_func parameter, 
3194  * when using pointers as keys in a #GHashTable.
3195  *
3196  * Returns: a hash value corresponding to the key.
3197  */
3198 guint
3199 g_direct_hash (gconstpointer v)
3200 {
3201   return GPOINTER_TO_UINT (v);
3202 }
3203
3204 /**
3205  * g_direct_equal:
3206  * @v1: a key.
3207  * @v2: a key to compare with @v1.
3208  *
3209  * Compares two #gpointer arguments and returns %TRUE if they are equal.
3210  * It can be passed to g_hash_table_new() as the @key_equal_func
3211  * parameter, when using pointers as keys in a #GHashTable.
3212  * 
3213  * Returns: %TRUE if the two keys match.
3214  */
3215 gboolean
3216 g_direct_equal (gconstpointer v1,
3217                 gconstpointer v2)
3218 {
3219   return v1 == v2;
3220 }
3221
3222 /**
3223  * g_int_equal:
3224  * @v1: a pointer to a #gint key.
3225  * @v2: a pointer to a #gint key to compare with @v1.
3226  *
3227  * Compares the two #gint values being pointed to and returns 
3228  * %TRUE if they are equal.
3229  * It can be passed to g_hash_table_new() as the @key_equal_func
3230  * parameter, when using pointers to integers as keys in a #GHashTable.
3231  * 
3232  * Returns: %TRUE if the two keys match.
3233  */
3234 gboolean
3235 g_int_equal (gconstpointer v1,
3236              gconstpointer v2)
3237 {
3238   return *((const gint*) v1) == *((const gint*) v2);
3239 }
3240
3241 /**
3242  * g_int_hash:
3243  * @v: a pointer to a #gint key
3244  *
3245  * Converts a pointer to a #gint to a hash value.
3246  * It can be passed to g_hash_table_new() as the @hash_func parameter, 
3247  * when using pointers to integers values as keys in a #GHashTable.
3248  *
3249  * Returns: a hash value corresponding to the key.
3250  */
3251 guint
3252 g_int_hash (gconstpointer v)
3253 {
3254   return *(const gint*) v;
3255 }
3256
3257 /**
3258  * g_int64_equal:
3259  * @v1: a pointer to a #gint64 key.
3260  * @v2: a pointer to a #gint64 key to compare with @v1.
3261  *
3262  * Compares the two #gint64 values being pointed to and returns 
3263  * %TRUE if they are equal.
3264  * It can be passed to g_hash_table_new() as the @key_equal_func
3265  * parameter, when using pointers to 64-bit integers as keys in a #GHashTable.
3266  * 
3267  * Returns: %TRUE if the two keys match.
3268  *
3269  * Since: 2.22
3270  */
3271 gboolean
3272 g_int64_equal (gconstpointer v1,
3273                gconstpointer v2)
3274 {
3275   return *((const gint64*) v1) == *((const gint64*) v2);
3276 }
3277
3278 /**
3279  * g_int64_hash:
3280  * @v: a pointer to a #gint64 key
3281  *
3282  * Converts a pointer to a #gint64 to a hash value.
3283  * It can be passed to g_hash_table_new() as the @hash_func parameter, 
3284  * when using pointers to 64-bit integers values as keys in a #GHashTable.
3285  *
3286  * Returns: a hash value corresponding to the key.
3287  *
3288  * Since: 2.22
3289  */
3290 guint
3291 g_int64_hash (gconstpointer v)
3292 {
3293   return (guint) *(const gint64*) v;
3294 }
3295
3296 /**
3297  * g_double_equal:
3298  * @v1: a pointer to a #gdouble key.
3299  * @v2: a pointer to a #gdouble key to compare with @v1.
3300  *
3301  * Compares the two #gdouble values being pointed to and returns 
3302  * %TRUE if they are equal.
3303  * It can be passed to g_hash_table_new() as the @key_equal_func
3304  * parameter, when using pointers to doubles as keys in a #GHashTable.
3305  * 
3306  * Returns: %TRUE if the two keys match.
3307  *
3308  * Since: 2.22
3309  */
3310 gboolean
3311 g_double_equal (gconstpointer v1,
3312                 gconstpointer v2)
3313 {
3314   return *((const gdouble*) v1) == *((const gdouble*) v2);
3315 }
3316
3317 /**
3318  * g_double_hash:
3319  * @v: a pointer to a #gdouble key
3320  *
3321  * Converts a pointer to a #gdouble to a hash value.
3322  * It can be passed to g_hash_table_new() as the @hash_func parameter, 
3323  * when using pointers to doubles as keys in a #GHashTable.
3324  *
3325  * Returns: a hash value corresponding to the key.
3326  *
3327  * Since: 2.22
3328  */
3329 guint
3330 g_double_hash (gconstpointer v)
3331 {
3332   return (guint) *(const gdouble*) v;
3333 }
3334
3335 /**
3336  * g_nullify_pointer:
3337  * @nullify_location: the memory address of the pointer.
3338  * 
3339  * Set the pointer at the specified location to %NULL.
3340  **/
3341 void
3342 g_nullify_pointer (gpointer *nullify_location)
3343 {
3344   g_return_if_fail (nullify_location != NULL);
3345
3346   *nullify_location = NULL;
3347 }
3348
3349 /**
3350  * g_get_codeset:
3351  * 
3352  * Get the codeset for the current locale.
3353  * 
3354  * Return value: a newly allocated string containing the name
3355  * of the codeset. This string must be freed with g_free().
3356  **/
3357 gchar *
3358 g_get_codeset (void)
3359 {
3360   const gchar *charset;
3361
3362   g_get_charset (&charset);
3363
3364   return g_strdup (charset);
3365 }
3366
3367 /* This is called from g_thread_init(). It's used to
3368  * initialize some static data in a threadsafe way.
3369  */
3370 void
3371 _g_utils_thread_init (void)
3372 {
3373   g_get_language_names ();
3374 }
3375
3376 #ifdef G_OS_WIN32
3377
3378 /**
3379  * _glib_get_locale_dir:
3380  *
3381  * Return the path to the share\locale or lib\locale subfolder of the
3382  * GLib installation folder. The path is in the system codepage. We
3383  * have to use system codepage as bindtextdomain() doesn't have a
3384  * UTF-8 interface.
3385  */
3386 static gchar *
3387 _glib_get_locale_dir (void)
3388 {
3389   gchar *install_dir = NULL, *locale_dir;
3390   gchar *retval = NULL;
3391
3392   if (glib_dll != NULL)
3393     install_dir = g_win32_get_package_installation_directory_of_module (glib_dll);
3394
3395   if (install_dir)
3396     {
3397       /*
3398        * Append "/share/locale" or "/lib/locale" depending on whether
3399        * autoconfigury detected GNU gettext or not.
3400        */
3401       const char *p = GLIB_LOCALE_DIR + strlen (GLIB_LOCALE_DIR);
3402       while (*--p != '/')
3403         ;
3404       while (*--p != '/')
3405         ;
3406
3407       locale_dir = g_build_filename (install_dir, p, NULL);
3408
3409       retval = g_win32_locale_filename_from_utf8 (locale_dir);
3410
3411       g_free (install_dir);
3412       g_free (locale_dir);
3413     }
3414
3415   if (retval)
3416     return retval;
3417   else
3418     return g_strdup ("");
3419 }
3420
3421 #undef GLIB_LOCALE_DIR
3422
3423 #endif /* G_OS_WIN32 */
3424
3425 /**
3426  * glib_gettext:
3427  * @str: The string to be translated
3428  *
3429  * Returns the translated string from the glib translations.
3430  * This is an internal function and should only be used by
3431  * the internals of glib (such as libgio).
3432  *
3433  * Returns: the transation of @str to the current locale
3434  */
3435 G_CONST_RETURN gchar *
3436 glib_gettext (const gchar *str)
3437 {
3438   static gboolean _glib_gettext_initialized = FALSE;
3439
3440   if (!_glib_gettext_initialized)
3441     {
3442 #ifdef G_OS_WIN32
3443       gchar *tmp = _glib_get_locale_dir ();
3444       bindtextdomain (GETTEXT_PACKAGE, tmp);
3445       g_free (tmp);
3446 #else
3447       bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
3448 #endif
3449 #    ifdef HAVE_BIND_TEXTDOMAIN_CODESET
3450       bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
3451 #    endif
3452       _glib_gettext_initialized = TRUE;
3453     }
3454   
3455   return g_dgettext (GETTEXT_PACKAGE, str);
3456 }
3457
3458 #if defined (G_OS_WIN32) && !defined (_WIN64)
3459
3460 /* Binary compatibility versions. Not for newly compiled code. */
3461
3462 #undef g_find_program_in_path
3463
3464 gchar*
3465 g_find_program_in_path (const gchar *program)
3466 {
3467   gchar *utf8_program = g_locale_to_utf8 (program, -1, NULL, NULL, NULL);
3468   gchar *utf8_retval = g_find_program_in_path_utf8 (utf8_program);
3469   gchar *retval;
3470
3471   g_free (utf8_program);
3472   if (utf8_retval == NULL)
3473     return NULL;
3474   retval = g_locale_from_utf8 (utf8_retval, -1, NULL, NULL, NULL);
3475   g_free (utf8_retval);
3476
3477   return retval;
3478 }
3479
3480 #undef g_get_current_dir
3481
3482 gchar*
3483 g_get_current_dir (void)
3484 {
3485   gchar *utf8_dir = g_get_current_dir_utf8 ();
3486   gchar *dir = g_locale_from_utf8 (utf8_dir, -1, NULL, NULL, NULL);
3487   g_free (utf8_dir);
3488   return dir;
3489 }
3490
3491 #undef g_getenv
3492
3493 G_CONST_RETURN gchar*
3494 g_getenv (const gchar *variable)
3495 {
3496   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3497   const gchar *utf8_value = g_getenv_utf8 (utf8_variable);
3498   gchar *value;
3499   GQuark quark;
3500
3501   g_free (utf8_variable);
3502   if (!utf8_value)
3503     return NULL;
3504   value = g_locale_from_utf8 (utf8_value, -1, NULL, NULL, NULL);
3505   quark = g_quark_from_string (value);
3506   g_free (value);
3507
3508   return g_quark_to_string (quark);
3509 }
3510
3511 #undef g_setenv
3512
3513 gboolean
3514 g_setenv (const gchar *variable, 
3515           const gchar *value, 
3516           gboolean     overwrite)
3517 {
3518   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3519   gchar *utf8_value = g_locale_to_utf8 (value, -1, NULL, NULL, NULL);
3520   gboolean retval = g_setenv_utf8 (utf8_variable, utf8_value, overwrite);
3521
3522   g_free (utf8_variable);
3523   g_free (utf8_value);
3524
3525   return retval;
3526 }
3527
3528 #undef g_unsetenv
3529
3530 void
3531 g_unsetenv (const gchar *variable)
3532 {
3533   gchar *utf8_variable = g_locale_to_utf8 (variable, -1, NULL, NULL, NULL);
3534
3535   g_unsetenv_utf8 (utf8_variable);
3536
3537   g_free (utf8_variable);
3538 }
3539
3540 #undef g_get_user_name
3541
3542 G_CONST_RETURN gchar*
3543 g_get_user_name (void)
3544 {
3545   g_get_any_init_locked ();
3546   return g_user_name_cp;
3547 }
3548
3549 #undef g_get_real_name
3550
3551 G_CONST_RETURN gchar*
3552 g_get_real_name (void)
3553 {
3554   g_get_any_init_locked ();
3555   return g_real_name_cp;
3556 }
3557
3558 #undef g_get_home_dir
3559
3560 G_CONST_RETURN gchar*
3561 g_get_home_dir (void)
3562 {
3563   g_get_any_init_locked ();
3564   return g_home_dir_cp;
3565 }
3566
3567 #undef g_get_tmp_dir
3568
3569 G_CONST_RETURN gchar*
3570 g_get_tmp_dir (void)
3571 {
3572   g_get_any_init_locked ();
3573   return g_tmp_dir_cp;
3574 }
3575
3576 #endif
3577
3578 #define __G_UTILS_C__
3579 #include "galiasdef.c"