Remove definition of g_hash_table_freeze and g_hash_table_thaw. Instead
[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 #ifdef HAVE_CONFIG_H
32 #include <config.h>
33 #endif
34
35 #ifdef HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38 #include <stdarg.h>
39 #include <stdlib.h>
40 #include <stdio.h>
41 #include <string.h>
42 #include <errno.h>
43 #ifdef HAVE_PWD_H
44 #include <pwd.h>
45 #endif
46 #include <sys/types.h>
47 #ifdef HAVE_SYS_PARAM_H
48 #include <sys/param.h>
49 #endif
50
51 /* implement Glib's inline functions
52  */
53 #define G_IMPLEMENT_INLINES 1
54 #define __G_UTILS_C__
55 #include "glib.h"
56
57 #ifdef  MAXPATHLEN
58 #define G_PATH_LENGTH   MAXPATHLEN
59 #elif   defined (PATH_MAX)
60 #define G_PATH_LENGTH   PATH_MAX
61 #elif   defined (_PC_PATH_MAX)
62 #define G_PATH_LENGTH   sysconf(_PC_PATH_MAX)
63 #else   
64 #define G_PATH_LENGTH   2048
65 #endif
66
67 #ifdef G_PLATFORM_WIN32
68 #  define STRICT                        /* Strict typing, please */
69 #  include <windows.h>
70 #  undef STRICT
71 #  include <ctype.h>
72 #endif /* G_PLATFORM_WIN32 */
73
74 #ifdef G_OS_WIN32
75 #  include <direct.h>
76 #endif
77
78 #ifdef HAVE_CODESET
79 #include <langinfo.h>
80 #endif
81
82 const guint glib_major_version = GLIB_MAJOR_VERSION;
83 const guint glib_minor_version = GLIB_MINOR_VERSION;
84 const guint glib_micro_version = GLIB_MICRO_VERSION;
85 const guint glib_interface_age = GLIB_INTERFACE_AGE;
86 const guint glib_binary_age = GLIB_BINARY_AGE;
87
88 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
89 void 
90 g_memmove (gpointer dest, gconstpointer src, gulong len)
91 {
92   gchar* destptr = dest;
93   const gchar* srcptr = src;
94   if (src + len < dest || dest + len < src)
95     {
96       bcopy (src, dest, len);
97       return;
98     }
99   else if (dest <= src)
100     {
101       while (len--)
102         *(destptr++) = *(srcptr++);
103     }
104   else
105     {
106       destptr += len;
107       srcptr += len;
108       while (len--)
109         *(--destptr) = *(--srcptr);
110     }
111 }
112 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
113
114 void
115 g_atexit (GVoidFunc func)
116 {
117   gint result;
118   const gchar *error = NULL;
119
120   /* keep this in sync with glib.h */
121
122 #ifdef  G_NATIVE_ATEXIT
123   result = ATEXIT (func);
124   if (result)
125     error = g_strerror (errno);
126 #elif defined (HAVE_ATEXIT)
127 #  ifdef NeXT /* @#%@! NeXTStep */
128   result = !atexit ((void (*)(void)) func);
129   if (result)
130     error = g_strerror (errno);
131 #  else
132   result = atexit ((void (*)(void)) func);
133   if (result)
134     error = g_strerror (errno);
135 #  endif /* NeXT */
136 #elif defined (HAVE_ON_EXIT)
137   result = on_exit ((void (*)(int, void *)) func, NULL);
138   if (result)
139     error = g_strerror (errno);
140 #else
141   result = 0;
142   error = "no implementation";
143 #endif /* G_NATIVE_ATEXIT */
144
145   if (error)
146     g_error ("Could not register atexit() function: %s", error);
147 }
148
149 /* Based on execvp() from GNU Libc.
150  * Some of this code is cut-and-pasted into gspawn.c
151  */
152
153 static gchar*
154 my_strchrnul (const gchar *str, gchar c)
155 {
156   gchar *p = (gchar*)str;
157   while (*p && (*p != c))
158     ++p;
159
160   return p;
161 }
162
163 #ifdef G_OS_WIN32
164
165 gchar *inner_find_program_in_path (const gchar *program);
166
167 gchar*
168 g_find_program_in_path (const gchar *program)
169 {
170   const gchar *last_dot = strrchr (program, '.');
171
172   if (last_dot == NULL || strchr (last_dot, '\\') != NULL)
173     {
174       const gint program_length = strlen (program);
175       const gchar *pathext = getenv ("PATHEXT");
176       const gchar *p;
177       gchar *decorated_program;
178       gchar *retval;
179
180       if (pathext == NULL)
181         pathext = ".com;.exe;.bat";
182
183       p = pathext;
184       do
185         {
186           pathext = p;
187           p = my_strchrnul (pathext, ';');
188
189           decorated_program = g_malloc (program_length + (p-pathext) + 1);
190           memcpy (decorated_program, program, program_length);
191           memcpy (decorated_program+program_length, pathext, p-pathext);
192           decorated_program [program_length + (p-pathext)] = '\0';
193           
194           retval = inner_find_program_in_path (decorated_program);
195           g_free (decorated_program);
196
197           if (retval != NULL)
198             return retval;
199         } while (*p++ != '\0');
200       return NULL;
201     }
202   else
203     return inner_find_program_in_path (program);
204 }
205
206 #define g_find_program_in_path inner_find_program_in_path
207 #endif
208
209 /**
210  * g_find_program_in_path:
211  * @program: a program name
212  * 
213  * Locates the first executable named @program in the user's path, in the
214  * same way that execvp() would locate it. Returns an allocated string
215  * with the absolute path name, or NULL if the program is not found in
216  * the path. If @program is already an absolute path, returns a copy of
217  * @program if @program exists and is executable, and NULL otherwise.
218  * 
219  * On Windows, if @program does not have a file type suffix, tries to
220  * append the suffixes in the PATHEXT environment variable (if that
221  * doesn't exists, the suffixes .com, .exe, and .bat) in turn, and
222  * then look for the resulting file name in the same way as
223  * CreateProcess() would. This means first in the directory where the
224  * program was loaded from, then in the current directory, then in the
225  * Windows 32-bit system directory, then in the Windows directory, and
226  * finally in the directories in the PATH environment variable. If
227  * the program is found, the return value contains the full name
228  * including the type suffix.
229  *
230  * Return value: absolute path, or NULL
231  **/
232 gchar*
233 g_find_program_in_path (const gchar *program)
234 {
235   const gchar *path, *p;
236   gchar *name, *freeme;
237 #ifdef G_OS_WIN32
238   gchar *path_tmp;
239 #endif
240   size_t len;
241   size_t pathlen;
242
243   g_return_val_if_fail (program != NULL, NULL);
244
245   /* If it is an absolute path, or a relative path including subdirectories,
246    * don't look in PATH.
247    */
248   if (g_path_is_absolute (program)
249       || strchr (program, G_DIR_SEPARATOR) != NULL)
250     {
251       if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE))
252         return g_strdup (program);
253       else
254         return NULL;
255     }
256   
257   path = g_getenv ("PATH");
258 #ifdef G_OS_UNIX
259   if (path == NULL)
260     {
261       /* There is no `PATH' in the environment.  The default
262        * search path in GNU libc is the current directory followed by
263        * the path `confstr' returns for `_CS_PATH'.
264        */
265       
266       /* In GLib we put . last, for security, and don't use the
267        * unportable confstr(); UNIX98 does not actually specify
268        * what to search if PATH is unset. POSIX may, dunno.
269        */
270       
271       path = "/bin:/usr/bin:.";
272     }
273 #else
274   {
275     gchar *tmp;
276     gchar moddir[MAXPATHLEN], sysdir[MAXPATHLEN], windir[MAXPATHLEN];
277
278     GetModuleFileName (NULL, moddir, sizeof (moddir));
279     tmp = g_path_get_dirname (moddir);
280     GetSystemDirectory (sysdir, sizeof (sysdir));
281     GetWindowsDirectory (windir, sizeof (windir));
282     path_tmp = g_strconcat (tmp, ";.;", sysdir, ";", windir,
283                             (path != NULL ? ";" : NULL),
284                             (path != NULL ? path : NULL),
285                             NULL);
286     g_free (tmp);
287     path = path_tmp;
288   }
289 #endif
290   
291   len = strlen (program) + 1;
292   pathlen = strlen (path);
293   freeme = name = g_malloc (pathlen + len + 1);
294   
295   /* Copy the file name at the top, including '\0'  */
296   memcpy (name + pathlen + 1, program, len);
297   name = name + pathlen;
298   /* And add the slash before the filename  */
299   *name = G_DIR_SEPARATOR;
300   
301   p = path;
302   do
303     {
304       char *startp;
305
306       path = p;
307       p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
308
309       if (p == path)
310         /* Two adjacent colons, or a colon at the beginning or the end
311          * of `PATH' means to search the current directory.
312          */
313         startp = name + 1;
314       else
315         startp = memcpy (name - (p - path), path, p - path);
316
317       if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE))
318         {
319           gchar *ret;
320           ret = g_strdup (startp);
321           g_free (freeme);
322 #ifdef G_OS_WIN32
323           g_free (path_tmp);
324 #endif
325           return ret;
326         }
327     }
328   while (*p++ != '\0');
329   
330   g_free (freeme);
331 #ifdef G_OS_WIN32
332   g_free (path_tmp);
333 #endif
334
335   return NULL;
336 }
337
338 gint
339 g_snprintf (gchar       *str,
340             gulong       n,
341             gchar const *fmt,
342             ...)
343 {
344 #ifdef  HAVE_VSNPRINTF
345   va_list args;
346   gint retval;
347   
348   g_return_val_if_fail (str != NULL, 0);
349   g_return_val_if_fail (n > 0, 0);
350   g_return_val_if_fail (fmt != NULL, 0);
351
352   va_start (args, fmt);
353   retval = vsnprintf (str, n, fmt, args);
354   va_end (args);
355
356   if (retval < 0)
357     {
358       str[n-1] = '\0';
359       retval = strlen (str);
360     }
361
362   return retval;
363 #else   /* !HAVE_VSNPRINTF */
364   gchar *printed;
365   va_list args;
366   
367   g_return_val_if_fail (str != NULL, 0);
368   g_return_val_if_fail (n > 0, 0);
369   g_return_val_if_fail (fmt != NULL, 0);
370
371   va_start (args, fmt);
372   printed = g_strdup_vprintf (fmt, args);
373   va_end (args);
374   
375   strncpy (str, printed, n);
376   str[n-1] = '\0';
377
378   g_free (printed);
379   
380   return strlen (str);
381 #endif  /* !HAVE_VSNPRINTF */
382 }
383
384 gint
385 g_vsnprintf (gchar       *str,
386              gulong       n,
387              gchar const *fmt,
388              va_list      args)
389 {
390 #ifdef  HAVE_VSNPRINTF
391   gint retval;
392   
393   g_return_val_if_fail (str != NULL, 0);
394   g_return_val_if_fail (n > 0, 0);
395   g_return_val_if_fail (fmt != NULL, 0);
396
397   retval = vsnprintf (str, n, fmt, args);
398   
399   if (retval < 0)
400     {
401       str[n-1] = '\0';
402       retval = strlen (str);
403     }
404
405   return retval;
406 #else   /* !HAVE_VSNPRINTF */
407   gchar *printed;
408   
409   g_return_val_if_fail (str != NULL, 0);
410   g_return_val_if_fail (n > 0, 0);
411   g_return_val_if_fail (fmt != NULL, 0);
412
413   printed = g_strdup_vprintf (fmt, args);
414   strncpy (str, printed, n);
415   str[n-1] = '\0';
416
417   g_free (printed);
418   
419   return strlen (str);
420 #endif /* !HAVE_VSNPRINTF */
421 }
422
423 guint        
424 g_parse_debug_string  (const gchar     *string, 
425                        const GDebugKey *keys, 
426                        guint            nkeys)
427 {
428   guint i;
429   guint result = 0;
430   
431   g_return_val_if_fail (string != NULL, 0);
432   
433   if (!g_strcasecmp (string, "all"))
434     {
435       for (i=0; i<nkeys; i++)
436         result |= keys[i].value;
437     }
438   else
439     {
440       gchar *str = g_strdup (string);
441       gchar *p = str;
442       gchar *q;
443       gboolean done = FALSE;
444       
445       while (*p && !done)
446         {
447           q = strchr (p, ':');
448           if (!q)
449             {
450               q = p + strlen(p);
451               done = TRUE;
452             }
453           
454           *q = 0;
455           
456           for (i=0; i<nkeys; i++)
457             if (!g_strcasecmp(keys[i].key, p))
458               result |= keys[i].value;
459           
460           p = q+1;
461         }
462       
463       g_free (str);
464     }
465   
466   return result;
467 }
468
469 G_CONST_RETURN gchar*
470 g_basename (const gchar    *file_name)
471 {
472   register gchar *base;
473   
474   g_return_val_if_fail (file_name != NULL, NULL);
475   
476   base = strrchr (file_name, G_DIR_SEPARATOR);
477   if (base)
478     return base + 1;
479
480 #ifdef G_OS_WIN32
481   if (isalpha (file_name[0]) && file_name[1] == ':')
482     return (gchar*) file_name + 2;
483 #endif /* G_OS_WIN32 */
484   
485   return (gchar*) file_name;
486 }
487
488 gchar*
489 g_path_get_basename (const gchar   *file_name)
490 {
491   register gint base;
492   register gint last_nonslash;
493   guint len;
494   gchar *retval;
495  
496   g_return_val_if_fail (file_name != NULL, NULL);
497   
498   if (file_name[0] == '\0')
499     /* empty string */
500     return g_strdup (".");
501
502   last_nonslash = strlen (file_name) - 1;
503
504   while (last_nonslash >= 0 && file_name [last_nonslash] == G_DIR_SEPARATOR)
505     last_nonslash--;
506
507   if (last_nonslash == -1)
508     /* string only containing slashes */
509     return g_strdup (G_DIR_SEPARATOR_S);
510
511 #ifdef G_OS_WIN32
512   if (last_nonslash == 1 && isalpha (file_name[0]) && file_name[1] == ':')
513     /* string only containing slashes and a drive */
514     return g_strdup (G_DIR_SEPARATOR_S);
515 #endif /* G_OS_WIN32 */
516
517   base = last_nonslash;
518
519   while (base >=0 && file_name [base] != G_DIR_SEPARATOR)
520     base--;
521
522 #ifdef G_OS_WIN32
523   if (base == -1 && isalpha (file_name[0]) && file_name[1] == ':')
524     base = 1;
525 #endif /* G_OS_WIN32 */
526
527   len = last_nonslash - base;
528   retval = g_malloc (len + 1);
529   memcpy (retval, file_name + base + 1, len);
530   retval [len] = '\0';
531   return retval;
532 }
533
534 gboolean
535 g_path_is_absolute (const gchar *file_name)
536 {
537   g_return_val_if_fail (file_name != NULL, FALSE);
538   
539   if (file_name[0] == G_DIR_SEPARATOR)
540     return TRUE;
541
542 #ifdef G_OS_WIN32
543   /* Recognize drive letter on native Windows */
544   if (isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
545     return TRUE;
546 #endif /* G_OS_WIN32 */
547
548   return FALSE;
549 }
550
551 G_CONST_RETURN gchar*
552 g_path_skip_root (const gchar *file_name)
553 {
554   g_return_val_if_fail (file_name != NULL, NULL);
555   
556 #ifdef G_PLATFORM_WIN32
557   /* Skip \\server\share (Win32) or //server/share (Cygwin) */
558   if (file_name[0] == G_DIR_SEPARATOR &&
559       file_name[1] == G_DIR_SEPARATOR &&
560       file_name[2])
561     {
562       gchar *p;
563
564       if ((p = strchr (file_name + 2, G_DIR_SEPARATOR)) > file_name + 2 &&
565           p[1])
566         {
567           file_name = p + 1;
568
569           while (file_name[0] && file_name[0] != G_DIR_SEPARATOR)
570             file_name++;
571
572           /* Possibly skip a backslash after the share name */
573           if (file_name[0] == G_DIR_SEPARATOR)
574             file_name++;
575
576           return (gchar *)file_name;
577         }
578     }
579 #endif
580   
581   /* Skip initial slashes */
582   if (file_name[0] == G_DIR_SEPARATOR)
583     {
584       while (file_name[0] == G_DIR_SEPARATOR)
585         file_name++;
586       return (gchar *)file_name;
587     }
588
589 #ifdef G_OS_WIN32
590   /* Skip X:\ */
591   if (isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
592     return (gchar *)file_name + 3;
593 #endif
594
595   return NULL;
596 }
597
598 gchar*
599 g_path_get_dirname (const gchar    *file_name)
600 {
601   register gchar *base;
602   register guint len;
603   
604   g_return_val_if_fail (file_name != NULL, NULL);
605   
606   base = strrchr (file_name, G_DIR_SEPARATOR);
607   if (!base)
608     return g_strdup (".");
609   while (base > file_name && *base == G_DIR_SEPARATOR)
610     base--;
611   len = (guint) 1 + base - file_name;
612   
613   base = g_new (gchar, len + 1);
614   g_memmove (base, file_name, len);
615   base[len] = 0;
616   
617   return base;
618 }
619
620 gchar*
621 g_get_current_dir (void)
622 {
623   gchar *buffer = NULL;
624   gchar *dir = NULL;
625   static gulong max_len = 0;
626
627   if (max_len == 0) 
628     max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
629   
630   /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
631    * and, if that wasn't bad enough, hangs in doing so.
632    */
633 #if     (defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
634   buffer = g_new (gchar, max_len + 1);
635   *buffer = 0;
636   dir = getwd (buffer);
637 #else   /* !sun || !HAVE_GETCWD */
638   while (max_len < G_MAXULONG / 2)
639     {
640       buffer = g_new (gchar, max_len + 1);
641       *buffer = 0;
642       dir = getcwd (buffer, max_len);
643
644       if (dir || errno != ERANGE)
645         break;
646
647       g_free (buffer);
648       max_len *= 2;
649     }
650 #endif  /* !sun || !HAVE_GETCWD */
651   
652   if (!dir || !*buffer)
653     {
654       /* hm, should we g_error() out here?
655        * this can happen if e.g. "./" has mode \0000
656        */
657       buffer[0] = G_DIR_SEPARATOR;
658       buffer[1] = 0;
659     }
660
661   dir = g_strdup (buffer);
662   g_free (buffer);
663   
664   return dir;
665 }
666
667 G_CONST_RETURN gchar*
668 g_getenv (const gchar *variable)
669 {
670 #ifndef G_OS_WIN32
671   g_return_val_if_fail (variable != NULL, NULL);
672
673   return getenv (variable);
674 #else
675   G_LOCK_DEFINE_STATIC (getenv);
676   struct env_struct
677   {
678     gchar *key;
679     gchar *value;
680   } *env;
681   static GArray *environs = NULL;
682   gchar *system_env;
683   guint length, i;
684   gchar dummy[2];
685
686   g_return_val_if_fail (variable != NULL, NULL);
687   
688   G_LOCK (getenv);
689
690   if (!environs)
691     environs = g_array_new (FALSE, FALSE, sizeof (struct env_struct));
692
693   /* First we try to find the envinronment variable inside the already
694    * found ones.
695    */
696
697   for (i = 0; i < environs->len; i++)
698     {
699       env = &g_array_index (environs, struct env_struct, i);
700       if (strcmp (env->key, variable) == 0)
701         {
702           g_assert (env->value);
703           G_UNLOCK (getenv);
704           return env->value;
705         }
706     }
707
708   /* If not found, we ask the system */
709
710   system_env = getenv (variable);
711   if (!system_env)
712     {
713       G_UNLOCK (getenv);
714       return NULL;
715     }
716
717   /* On Windows NT, it is relatively typical that environment variables
718    * contain references to other environment variables. Handle that by
719    * calling ExpandEnvironmentStrings.
720    */
721
722   g_array_set_size (environs, environs->len + 1);
723
724   env = &g_array_index (environs, struct env_struct, environs->len - 1);
725
726   /* First check how much space we need */
727   length = ExpandEnvironmentStrings (system_env, dummy, 2);
728
729   /* Then allocate that much, and actualy do the expansion and insert
730    * the new found pair into our buffer 
731    */
732
733   env->value = g_malloc (length);
734   env->key = g_strdup (variable);
735
736   ExpandEnvironmentStrings (system_env, env->value, length);
737
738   G_UNLOCK (getenv);
739   return env->value;
740 #endif
741 }
742
743
744 G_LOCK_DEFINE_STATIC (g_utils_global);
745
746 static  gchar   *g_tmp_dir = NULL;
747 static  gchar   *g_user_name = NULL;
748 static  gchar   *g_real_name = NULL;
749 static  gchar   *g_home_dir = NULL;
750
751 /* HOLDS: g_utils_global_lock */
752 static void
753 g_get_any_init (void)
754 {
755   if (!g_tmp_dir)
756     {
757       g_tmp_dir = g_strdup (g_getenv ("TMPDIR"));
758       if (!g_tmp_dir)
759         g_tmp_dir = g_strdup (g_getenv ("TMP"));
760       if (!g_tmp_dir)
761         g_tmp_dir = g_strdup (g_getenv ("TEMP"));
762       
763 #ifdef P_tmpdir
764       if (!g_tmp_dir)
765         {
766           int k;
767           g_tmp_dir = g_strdup (P_tmpdir);
768           k = strlen (g_tmp_dir);
769           if (g_tmp_dir[k-1] == G_DIR_SEPARATOR)
770             g_tmp_dir[k-1] = '\0';
771         }
772 #endif
773       
774       if (!g_tmp_dir)
775         {
776 #ifndef G_OS_WIN32
777           g_tmp_dir = g_strdup ("/tmp");
778 #else /* G_OS_WIN32 */
779           g_tmp_dir = g_strdup ("C:\\");
780 #endif /* G_OS_WIN32 */
781         }
782       
783       if (!g_home_dir)
784         g_home_dir = g_strdup (g_getenv ("HOME"));
785       
786 #ifdef G_OS_WIN32
787       /* In case HOME is Unix-style (it happens), convert it to
788        * Windows style.
789        */
790       if (g_home_dir)
791         {
792           gchar *p;
793           while ((p = strchr (g_home_dir, '/')) != NULL)
794             *p = '\\';
795         }
796
797       if (!g_home_dir)
798         {
799           /* USERPROFILE is probably the closest equivalent to $HOME? */
800           if (getenv ("USERPROFILE") != NULL)
801             g_home_dir = g_strdup (g_getenv ("USERPROFILE"));
802         }
803
804       if (!g_home_dir)
805         {
806           /* At least at some time, HOMEDRIVE and HOMEPATH were used
807            * to point to the home directory, I think. But on Windows
808            * 2000 HOMEDRIVE seems to be equal to SYSTEMDRIVE, and
809            * HOMEPATH is its root "\"?
810            */
811           if (getenv ("HOMEDRIVE") != NULL && getenv ("HOMEPATH") != NULL)
812             {
813               gchar *homedrive, *homepath;
814               
815               homedrive = g_strdup (g_getenv ("HOMEDRIVE"));
816               homepath = g_strdup (g_getenv ("HOMEPATH"));
817               
818               g_home_dir = g_strconcat (homedrive, homepath, NULL);
819               g_free (homedrive);
820               g_free (homepath);
821             }
822         }
823 #endif /* G_OS_WIN32 */
824       
825 #ifdef HAVE_PWD_H
826       {
827         struct passwd *pw = NULL;
828         gpointer buffer = NULL;
829         
830 #  if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
831         struct passwd pwd;
832 #    ifdef _SC_GETPW_R_SIZE_MAX  
833         /* This reurns the maximum length */
834         guint bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
835 #    else /* _SC_GETPW_R_SIZE_MAX */
836         guint bufsize = 64;
837 #    endif /* _SC_GETPW_R_SIZE_MAX */
838         gint error;
839         
840         do
841           {
842             g_free (buffer);
843             buffer = g_malloc (bufsize);
844             errno = 0;
845             
846 #    ifdef HAVE_POSIX_GETPWUID_R
847             error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
848             error = error < 0 ? errno : error;
849 #    else /* HAVE_NONPOSIX_GETPWUID_R */
850 #      ifdef _AIX
851             error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
852             pw = error == 0 ? &pwd : NULL;
853 #      else /* !_AIX */
854             pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
855             error = pw ? 0 : errno;
856 #      endif /* !_AIX */            
857 #    endif /* HAVE_NONPOSIX_GETPWUID_R */
858             
859             if (!pw)
860               {
861                 /* we bail out prematurely if the user id can't be found
862                  * (should be pretty rare case actually), or if the buffer
863                  * should be sufficiently big and lookups are still not
864                  * successfull.
865                  */
866                 if (error == 0 || error == ENOENT)
867                   {
868                     g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
869                                (gulong) getuid ());
870                     break;
871                   }
872                 if (bufsize > 32 * 1024)
873                   {
874                     g_warning ("getpwuid_r(): failed due to: %s.",
875                                g_strerror (error));
876                     break;
877                   }
878                 
879                 bufsize *= 2;
880               }
881           }
882         while (!pw);
883 #  endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
884         
885         if (!pw)
886           {
887             setpwent ();
888             pw = getpwuid (getuid ());
889             endpwent ();
890           }
891         if (pw)
892           {
893             g_user_name = g_strdup (pw->pw_name);
894             g_real_name = g_strdup (pw->pw_gecos);
895             if (!g_home_dir)
896               g_home_dir = g_strdup (pw->pw_dir);
897           }
898         g_free (buffer);
899       }
900       
901 #else /* !HAVE_PWD_H */
902       
903 #  ifdef G_OS_WIN32
904       {
905         guint len = 17;
906         gchar buffer[17];
907         
908         if (GetUserName ((LPTSTR) buffer, (LPDWORD) &len))
909           {
910             g_user_name = g_strdup (buffer);
911             g_real_name = g_strdup (buffer);
912           }
913       }
914 #  endif /* G_OS_WIN32 */
915       
916 #endif /* !HAVE_PWD_H */
917       
918 #ifdef __EMX__
919       /* change '\\' in %HOME% to '/' */
920       g_strdelimit (g_home_dir, "\\",'/');
921 #endif
922       if (!g_user_name)
923         g_user_name = g_strdup ("somebody");
924       if (!g_real_name)
925         g_real_name = g_strdup ("Unknown");
926       else
927         {
928           gchar *p;
929
930           for (p = g_real_name; *p; p++)
931             if (*p == ',')
932               {
933                 *p = 0;
934                 p = g_strdup (g_real_name);
935                 g_free (g_real_name);
936                 g_real_name = p;
937                 break;
938               }
939         }
940     }
941 }
942
943 G_CONST_RETURN gchar*
944 g_get_user_name (void)
945 {
946   G_LOCK (g_utils_global);
947   if (!g_tmp_dir)
948     g_get_any_init ();
949   G_UNLOCK (g_utils_global);
950   
951   return g_user_name;
952 }
953
954 G_CONST_RETURN gchar*
955 g_get_real_name (void)
956 {
957   G_LOCK (g_utils_global);
958   if (!g_tmp_dir)
959     g_get_any_init ();
960   G_UNLOCK (g_utils_global);
961  
962   return g_real_name;
963 }
964
965 /* Return the home directory of the user. If there is a HOME
966  * environment variable, its value is returned, otherwise use some
967  * system-dependent way of finding it out. If no home directory can be
968  * deduced, return NULL.
969  */
970
971 G_CONST_RETURN gchar*
972 g_get_home_dir (void)
973 {
974   G_LOCK (g_utils_global);
975   if (!g_tmp_dir)
976     g_get_any_init ();
977   G_UNLOCK (g_utils_global);
978   
979   return g_home_dir;
980 }
981
982 /* Return a directory to be used to store temporary files. This is the
983  * value of the TMPDIR, TMP or TEMP environment variables (they are
984  * checked in that order). If none of those exist, use P_tmpdir from
985  * stdio.h.  If that isn't defined, return "/tmp" on POSIXly systems,
986  * and C:\ on Windows.
987  */
988
989 G_CONST_RETURN gchar*
990 g_get_tmp_dir (void)
991 {
992   G_LOCK (g_utils_global);
993   if (!g_tmp_dir)
994     g_get_any_init ();
995   G_UNLOCK (g_utils_global);
996   
997   return g_tmp_dir;
998 }
999
1000 static gchar *g_prgname = NULL;
1001
1002 gchar*
1003 g_get_prgname (void)
1004 {
1005   gchar* retval;
1006
1007   G_LOCK (g_utils_global);
1008   retval = g_prgname;
1009   G_UNLOCK (g_utils_global);
1010
1011   return retval;
1012 }
1013
1014 void
1015 g_set_prgname (const gchar *prgname)
1016 {
1017   gchar *c;
1018     
1019   G_LOCK (g_utils_global);
1020   c = g_prgname;
1021   g_prgname = g_strdup (prgname);
1022   g_free (c);
1023   G_UNLOCK (g_utils_global);
1024 }
1025
1026 guint
1027 g_direct_hash (gconstpointer v)
1028 {
1029   return GPOINTER_TO_UINT (v);
1030 }
1031
1032 gboolean
1033 g_direct_equal (gconstpointer v1,
1034                 gconstpointer v2)
1035 {
1036   return v1 == v2;
1037 }
1038
1039 gboolean
1040 g_int_equal (gconstpointer v1,
1041              gconstpointer v2)
1042 {
1043   return *((const gint*) v1) == *((const gint*) v2);
1044 }
1045
1046 guint
1047 g_int_hash (gconstpointer v)
1048 {
1049   return *(const gint*) v;
1050 }
1051
1052 /**
1053  * g_get_codeset:
1054  * 
1055  * Get the codeset for the current locale.
1056  * 
1057  * Return value: a newly allocated string containing the name
1058  * of the codeset. This string must be freed with g_free().
1059  **/
1060 gchar *
1061 g_get_codeset (void)
1062 {
1063 #ifdef HAVE_CODESET  
1064   char *result = nl_langinfo (CODESET);
1065   return g_strdup (result);
1066 #else
1067 #ifdef G_PLATFORM_WIN32
1068   return g_strdup_printf ("CP%d", GetACP ());
1069 #else
1070   /* FIXME: Do something more intelligent based on setlocale (LC_CTYPE, NULL)
1071    */
1072   return g_strdup ("ISO-8859-1");
1073 #endif
1074 #endif
1075 }
1076
1077 #ifdef ENABLE_NLS
1078
1079 #include <libintl.h>
1080
1081
1082 #ifndef GLIB_LOCALE_DIR
1083 #ifdef G_PLATFORM_WIN32
1084
1085 #define GLIB_LOCALE_DIR                                         \
1086   g_win32_get_package_installation_subdirectory                 \
1087   (GETTEXT_PACKAGE, g_strdup_printf ("glib-%d.%d.dll",          \
1088                                      GLIB_MAJOR_VERSION,        \
1089                                      GLIB_MINOR_VERSION),       \
1090    "locale")
1091
1092 #endif /* G_PLATFORM_WIN32 */
1093 #endif /* !GLIB_LOCALE_DIR */
1094
1095 G_CONST_RETURN gchar *
1096 _glib_gettext (const gchar *str)
1097 {
1098   static gboolean _glib_gettext_initialized = FALSE;
1099
1100   if (!_glib_gettext_initialized)
1101     {
1102       bindtextdomain(GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
1103       _glib_gettext_initialized = TRUE;
1104     }
1105   
1106   return dgettext (GETTEXT_PACKAGE, str);
1107 }
1108
1109 #endif /* ENABLE_NLS */
1110
1111