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 <string.h>
  40 #include <errno.h>
  41 #ifdef HAVE_PWD_H
  42 #include <pwd.h>
  43 #endif
  44 #include <sys/types.h>
  45 #ifdef HAVE_SYS_PARAM_H
  46 #include <sys/param.h>
  47 #endif
  48
  49 /* implement gutils's inline functions
  50  */
  51 #define G_IMPLEMENT_INLINES 1
  52 #define __G_UTILS_C__
  53 #include "glib.h"
  54 #include "gprintfint.h"
  55
  56 #ifdef  MAXPATHLEN
  57 #define G_PATH_LENGTH   MAXPATHLEN
  58 #elif   defined (PATH_MAX)
  59 #define G_PATH_LENGTH   PATH_MAX
  60 #elif   defined (_PC_PATH_MAX)
  61 #define G_PATH_LENGTH   sysconf(_PC_PATH_MAX)
  62 #else
  63 #define G_PATH_LENGTH   2048
  64 #endif
  65
  66 #ifdef G_PLATFORM_WIN32
  67 #  define STRICT                /* Strict typing, please */
  68 #  include <windows.h>
  69 #  undef STRICT
  70 #  include <lmcons.h>           /* For UNLEN */
  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 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
  83 #include <libintl.h>
  84 #endif
  85
  86 /* G_IS_DIR_SEPARATOR probably should be made public in GLib 2.4 */
  87 #ifdef G_OS_WIN32
  88 #define G_IS_DIR_SEPARATOR(c) (c == G_DIR_SEPARATOR || c == '/')
  89 #else
  90 #define G_IS_DIR_SEPARATOR(c) (c == G_DIR_SEPARATOR)
  91 #endif
  92
  93 const guint glib_major_version = GLIB_MAJOR_VERSION;
  94 const guint glib_minor_version = GLIB_MINOR_VERSION;
  95 const guint glib_micro_version = GLIB_MICRO_VERSION;
  96 const guint glib_interface_age = GLIB_INTERFACE_AGE;
  97 const guint glib_binary_age = GLIB_BINARY_AGE;
  98
  99 #if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)
 100 void
 101 g_memmove (gpointer dest, gconstpointer src, gulong len)
 102 {
 103   gchar* destptr = dest;
 104   const gchar* srcptr = src;
 105   if (src + len < dest || dest + len < src)
 106     {
 107       bcopy (src, dest, len);
 108       return;
 109     }
 110   else if (dest <= src)
 111     {
 112       while (len--)
 113         *(destptr++) = *(srcptr++);
 114     }
 115   else
 116     {
 117       destptr += len;
 118       srcptr += len;
 119       while (len--)
 120         *(--destptr) = *(--srcptr);
 121     }
 122 }
 123 #endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */
 124
 125 void
 126 g_atexit (GVoidFunc func)
 127 {
 128   gint result;
 129   const gchar *error = NULL;
 130
 131   /* keep this in sync with glib.h */
 132
 133 #ifdef  G_NATIVE_ATEXIT
 134   result = ATEXIT (func);
 135   if (result)
 136     error = g_strerror (errno);
 137 #elif defined (HAVE_ATEXIT)
 138 #  ifdef NeXT /* @#%@! NeXTStep */
 139   result = !atexit ((void (*)(void)) func);
 140   if (result)
 141     error = g_strerror (errno);
 142 #  else
 143   result = atexit ((void (*)(void)) func);
 144   if (result)
 145     error = g_strerror (errno);
 146 #  endif /* NeXT */
 147 #elif defined (HAVE_ON_EXIT)
 148   result = on_exit ((void (*)(int, void *)) func, NULL);
 149   if (result)
 150     error = g_strerror (errno);
 151 #else
 152   result = 0;
 153   error = "no implementation";
 154 #endif /* G_NATIVE_ATEXIT */
 155
 156   if (error)
 157     g_error ("Could not register atexit() function: %s", error);
 158 }
 159
 160 /* Based on execvp() from GNU Libc.
 161  * Some of this code is cut-and-pasted into gspawn.c
 162  */
 163
 164 static gchar*
 165 my_strchrnul (const gchar *str, gchar c)
 166 {
 167   gchar *p = (gchar*)str;
 168   while (*p && (*p != c))
 169     ++p;
 170
 171   return p;
 172 }
 173
 174 #ifdef G_OS_WIN32
 175
 176 static gchar *inner_find_program_in_path (const gchar *program);
 177
 178 gchar*
 179 g_find_program_in_path (const gchar *program)
 180 {
 181   const gchar *last_dot = strrchr (program, '.');
 182
 183   if (last_dot == NULL || strchr (last_dot, '\\') != NULL)
 184     {
 185       const gint program_length = strlen (program);
 186       const gchar *pathext = getenv ("PATHEXT");
 187       const gchar *p;
 188       gchar *decorated_program;
 189       gchar *retval;
 190
 191       if (pathext == NULL)
 192         pathext = ".com;.exe;.bat";
 193
 194       p = pathext;
 195       do
 196         {
 197           pathext = p;
 198           p = my_strchrnul (pathext, ';');
 199
 200           decorated_program = g_malloc (program_length + (p-pathext) + 1);
 201           memcpy (decorated_program, program, program_length);
 202           memcpy (decorated_program+program_length, pathext, p-pathext);
 203           decorated_program [program_length + (p-pathext)] = '\0';
 204
 205           retval = inner_find_program_in_path (decorated_program);
 206           g_free (decorated_program);
 207
 208           if (retval != NULL)
 209             return retval;
 210         } while (*p++ != '\0');
 211       return NULL;
 212     }
 213   else
 214     return inner_find_program_in_path (program);
 215 }
 216
 217 #define g_find_program_in_path inner_find_program_in_path
 218 #endif
 219
 220 /**
 221  * g_find_program_in_path:
 222  * @program: a program name
 223  *
 224  * Locates the first executable named @program in the user's path, in the
 225  * same way that execvp() would locate it. Returns an allocated string
 226  * with the absolute path name, or NULL if the program is not found in
 227  * the path. If @program is already an absolute path, returns a copy of
 228  * @program if @program exists and is executable, and NULL otherwise.
 229  *
 230  * On Windows, if @program does not have a file type suffix, tries to
 231  * append the suffixes in the PATHEXT environment variable (if that
 232  * doesn't exists, the suffixes .com, .exe, and .bat) in turn, and
 233  * then look for the resulting file name in the same way as
 234  * CreateProcess() would. This means first in the directory where the
 235  * program was loaded from, then in the current directory, then in the
 236  * Windows 32-bit system directory, then in the Windows directory, and
 237  * finally in the directories in the PATH environment variable. If
 238  * the program is found, the return value contains the full name
 239  * including the type suffix.
 240  *
 241  * Return value: absolute path, or NULL
 242  **/
 243 #ifdef G_OS_WIN32
 244 static
 245 #endif
 246 gchar*
 247 g_find_program_in_path (const gchar *program)
 248 {
 249   const gchar *path, *p;
 250   gchar *name, *freeme;
 251 #ifdef G_OS_WIN32
 252   gchar *path_tmp;
 253 #endif
 254   size_t len;
 255   size_t pathlen;
 256
 257   g_return_val_if_fail (program != NULL, NULL);
 258
 259   /* If it is an absolute path, or a relative path including subdirectories,
 260    * don't look in PATH.
 261    */
 262   if (g_path_is_absolute (program)
 263       || strchr (program, G_DIR_SEPARATOR) != NULL
 264 #ifdef G_OS_WIN32
 265       || strchr (program, '/') != NULL
 266 #endif
 267       )
 268     {
 269       if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE))
 270         return g_strdup (program);
 271       else
 272         return NULL;
 273     }
 274
 275   path = g_getenv ("PATH");
 276 #ifdef G_OS_UNIX
 277   if (path == NULL)
 278     {
 279       /* There is no `PATH' in the environment.  The default
 280        * search path in GNU libc is the current directory followed by
 281        * the path `confstr' returns for `_CS_PATH'.
 282        */
 283
 284       /* In GLib we put . last, for security, and don't use the
 285        * unportable confstr(); UNIX98 does not actually specify
 286        * what to search if PATH is unset. POSIX may, dunno.
 287        */
 288
 289       path = "/bin:/usr/bin:.";
 290     }
 291 #else
 292   {
 293     gchar *tmp;
 294     gchar moddir[MAXPATHLEN], sysdir[MAXPATHLEN], windir[MAXPATHLEN];
 295
 296     GetModuleFileName (NULL, moddir, sizeof (moddir));
 297     tmp = g_path_get_dirname (moddir);
 298     GetSystemDirectory (sysdir, sizeof (sysdir));
 299     GetWindowsDirectory (windir, sizeof (windir));
 300     path_tmp = g_strconcat (tmp, ";.;", sysdir, ";", windir,
 301                             (path != NULL ? ";" : NULL),
 302                             (path != NULL ? path : NULL),
 303                             NULL);
 304     g_free (tmp);
 305     path = path_tmp;
 306   }
 307 #endif
 308
 309   len = strlen (program) + 1;
 310   pathlen = strlen (path);
 311   freeme = name = g_malloc (pathlen + len + 1);
 312
 313   /* Copy the file name at the top, including '\0'  */
 314   memcpy (name + pathlen + 1, program, len);
 315   name = name + pathlen;
 316   /* And add the slash before the filename  */
 317   *name = G_DIR_SEPARATOR;
 318
 319   p = path;
 320   do
 321     {
 322       char *startp;
 323
 324       path = p;
 325       p = my_strchrnul (path, G_SEARCHPATH_SEPARATOR);
 326
 327       if (p == path)
 328         /* Two adjacent colons, or a colon at the beginning or the end
 329          * of `PATH' means to search the current directory.
 330          */
 331         startp = name + 1;
 332       else
 333         startp = memcpy (name - (p - path), path, p - path);
 334
 335       if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE))
 336         {
 337           gchar *ret;
 338           ret = g_strdup (startp);
 339           g_free (freeme);
 340 #ifdef G_OS_WIN32
 341           g_free (path_tmp);
 342 #endif
 343           return ret;
 344         }
 345     }
 346   while (*p++ != '\0');
 347
 348   g_free (freeme);
 349 #ifdef G_OS_WIN32
 350   g_free (path_tmp);
 351 #endif
 352
 353   return NULL;
 354 }
 355
 356 guint
 357 g_parse_debug_string  (const gchar     *string,
 358                        const GDebugKey *keys,
 359                        guint            nkeys)
 360 {
 361   guint i;
 362   guint result = 0;
 363
 364   g_return_val_if_fail (string != NULL, 0);
 365
 366   if (!g_ascii_strcasecmp (string, "all"))
 367     {
 368       for (i=0; i<nkeys; i++)
 369         result |= keys[i].value;
 370     }
 371   else
 372     {
 373       const gchar *p = string;
 374       const gchar *q;
 375       gboolean done = FALSE;
 376
 377       while (*p && !done)
 378         {
 379           q = strchr (p, ':');
 380           if (!q)
 381             {
 382               q = p + strlen(p);
 383               done = TRUE;
 384             }
 385
 386           for (i=0; i<nkeys; i++)
 387             if (g_ascii_strncasecmp(keys[i].key, p, q - p) == 0 &&
 388                 keys[i].key[q - p] == '\0')
 389               result |= keys[i].value;
 390
 391           p = q + 1;
 392         }
 393     }
 394
 395   return result;
 396 }
 397
 398 /**
 399  * g_basename:
 400  * @file_name: the name of the file.
 401  *
 402  * Gets the name of the file without any leading directory components.
 403  * It returns a pointer into the given file name string.
 404  *
 405  * Return value: the name of the file without any leading directory components.
 406  *
 407  * Deprecated: Use g_path_get_basename() instead, but notice that
 408  * g_path_get_basename() allocates new memory for the returned string, unlike
 409  * this function which returns a pointer into the argument.
 410  **/
 411 G_CONST_RETURN gchar*
 412 g_basename (const gchar    *file_name)
 413 {
 414   register gchar *base;
 415
 416   g_return_val_if_fail (file_name != NULL, NULL);
 417
 418   base = strrchr (file_name, G_DIR_SEPARATOR);
 419
 420 #ifdef G_OS_WIN32
 421   {
 422     gchar *q = strrchr (file_name, '/');
 423     if (base == NULL || (q != NULL && q > base))
 424         base = q;
 425   }
 426 #endif
 427
 428   if (base)
 429     return base + 1;
 430
 431 #ifdef G_OS_WIN32
 432   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 433     return (gchar*) file_name + 2;
 434 #endif /* G_OS_WIN32 */
 435
 436   return (gchar*) file_name;
 437 }
 438
 439 /**
 440  * g_path_get_basename:
 441  * @file_name: the name of the file.
 442  *
 443  * Gets the last component of the filename. If @file_name ends with a
 444  * directory separator it gets the component before the last slash. If
 445  * @file_name consists only of directory separators (and on Windows,
 446  * possibly a drive letter), a single separator is returned. If
 447  * @file_name is empty, it gets ".".
 448  *
 449  * Return value: a newly allocated string containing the last component of
 450  *   the filename.
 451  */
 452 gchar*
 453 g_path_get_basename (const gchar   *file_name)
 454 {
 455   register gssize base;
 456   register gssize last_nonslash;
 457   gsize len;
 458   gchar *retval;
 459
 460   g_return_val_if_fail (file_name != NULL, NULL);
 461
 462   if (file_name[0] == '\0')
 463     /* empty string */
 464     return g_strdup (".");
 465
 466   last_nonslash = strlen (file_name) - 1;
 467
 468   while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash]))
 469     last_nonslash--;
 470
 471   if (last_nonslash == -1)
 472     /* string only containing slashes */
 473     return g_strdup (G_DIR_SEPARATOR_S);
 474
 475 #ifdef G_OS_WIN32
 476   if (last_nonslash == 1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 477     /* string only containing slashes and a drive */
 478     return g_strdup (G_DIR_SEPARATOR_S);
 479 #endif /* G_OS_WIN32 */
 480
 481   base = last_nonslash;
 482
 483   while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base]))
 484     base--;
 485
 486 #ifdef G_OS_WIN32
 487   if (base == -1 && g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
 488     base = 1;
 489 #endif /* G_OS_WIN32 */
 490
 491   len = last_nonslash - base;
 492   retval = g_malloc (len + 1);
 493   memcpy (retval, file_name + base + 1, len);
 494   retval [len] = '\0';
 495   return retval;
 496 }
 497
 498 gboolean
 499 g_path_is_absolute (const gchar *file_name)
 500 {
 501   g_return_val_if_fail (file_name != NULL, FALSE);
 502
 503   if (G_IS_DIR_SEPARATOR (file_name[0]))
 504     return TRUE;
 505
 506 #ifdef G_OS_WIN32
 507   /* Recognize drive letter on native Windows */
 508   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
 509     return TRUE;
 510 #endif /* G_OS_WIN32 */
 511
 512   return FALSE;
 513 }
 514
 515 G_CONST_RETURN gchar*
 516 g_path_skip_root (const gchar *file_name)
 517 {
 518   g_return_val_if_fail (file_name != NULL, NULL);
 519
 520 #ifdef G_PLATFORM_WIN32
 521   /* Skip \\server\share or //server/share */
 522   if (G_IS_DIR_SEPARATOR (file_name[0]) &&
 523       G_IS_DIR_SEPARATOR (file_name[1]) &&
 524       file_name[2])
 525     {
 526       gchar *p;
 527
 528       p = strchr (file_name + 2, G_DIR_SEPARATOR);
 529 #ifdef G_OS_WIN32
 530       {
 531         gchar *q = strchr (file_name + 2, '/');
 532         if (p == NULL || (q != NULL && q < p))
 533           p = q;
 534       }
 535 #endif
 536       if (p &&
 537           p > file_name + 2 &&
 538           p[1])
 539         {
 540           file_name = p + 1;
 541
 542           while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0]))
 543             file_name++;
 544
 545           /* Possibly skip a backslash after the share name */
 546           if (G_IS_DIR_SEPARATOR (file_name[0]))
 547             file_name++;
 548
 549           return (gchar *)file_name;
 550         }
 551     }
 552 #endif
 553
 554   /* Skip initial slashes */
 555   if (G_IS_DIR_SEPARATOR (file_name[0]))
 556     {
 557       while (G_IS_DIR_SEPARATOR (file_name[0]))
 558         file_name++;
 559       return (gchar *)file_name;
 560     }
 561
 562 #ifdef G_OS_WIN32
 563   /* Skip X:\ */
 564   if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
 565     return (gchar *)file_name + 3;
 566 #endif
 567
 568   return NULL;
 569 }
 570
 571 gchar*
 572 g_path_get_dirname (const gchar    *file_name)
 573 {
 574   register gchar *base;
 575   register gsize len;
 576
 577   g_return_val_if_fail (file_name != NULL, NULL);
 578
 579   base = strrchr (file_name, G_DIR_SEPARATOR);
 580 #ifdef G_OS_WIN32
 581   {
 582     gchar *q = strrchr (file_name, '/');
 583     if (base == NULL || (q != NULL && q > base))
 584         base = q;
 585   }
 586 #endif
 587   if (!base)
 588     return g_strdup (".");
 589   while (base > file_name && G_IS_DIR_SEPARATOR (*base))
 590     base--;
 591   len = (guint) 1 + base - file_name;
 592
 593   base = g_new (gchar, len + 1);
 594   g_memmove (base, file_name, len);
 595   base[len] = 0;
 596
 597   return base;
 598 }
 599
 600 gchar*
 601 g_get_current_dir (void)
 602 {
 603   gchar *buffer = NULL;
 604   gchar *dir = NULL;
 605   static gulong max_len = 0;
 606
 607   if (max_len == 0)
 608     max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
 609
 610   /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
 611    * and, if that wasn't bad enough, hangs in doing so.
 612    */
 613 #if     (defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
 614   buffer = g_new (gchar, max_len + 1);
 615   *buffer = 0;
 616   dir = getwd (buffer);
 617 #else   /* !sun || !HAVE_GETCWD */
 618   while (max_len < G_MAXULONG / 2)
 619     {
 620       buffer = g_new (gchar, max_len + 1);
 621       *buffer = 0;
 622       dir = getcwd (buffer, max_len);
 623
 624       if (dir || errno != ERANGE)
 625         break;
 626
 627       g_free (buffer);
 628       max_len *= 2;
 629     }
 630 #endif  /* !sun || !HAVE_GETCWD */
 631
 632   if (!dir || !*buffer)
 633     {
 634       /* hm, should we g_error() out here?
 635        * this can happen if e.g. "./" has mode \0000
 636        */
 637       buffer[0] = G_DIR_SEPARATOR;
 638       buffer[1] = 0;
 639     }
 640
 641   dir = g_strdup (buffer);
 642   g_free (buffer);
 643
 644   return dir;
 645 }
 646
 647 /**
 648  * g_getenv:
 649  * @variable: the environment variable to get.
 650  *
 651  * Returns an environment variable.
 652  *
 653  * Return value: the value of the environment variable, or %NULL if the environment
 654  * variable is not found. The returned string may be overwritten by the next call to g_getenv(),
 655  * g_setenv() or g_unsetenv().
 656  **/
 657 G_CONST_RETURN gchar*
 658 g_getenv (const gchar *variable)
 659 {
 660 #ifndef G_OS_WIN32
 661   g_return_val_if_fail (variable != NULL, NULL);
 662
 663   return getenv (variable);
 664 #else
 665   GQuark quark;
 666   gchar *system_env;
 667   gchar *expanded_env;
 668   guint length;
 669   gchar dummy[2];
 670
 671   g_return_val_if_fail (variable != NULL, NULL);
 672
 673   system_env = getenv (variable);
 674   if (!system_env)
 675     return NULL;
 676
 677   /* On Windows NT, it is relatively typical that environment
 678    * variables contain references to other environment variables. If
 679    * so, use ExpandEnvironmentStrings(). (If all software was written
 680    * in the best possible way, such environment variables would be
 681    * stored in the Registry as REG_EXPAND_SZ type values, and would
 682    * then get automatically expanded before the program sees them. But
 683    * there is broken software that stores environment variables as
 684    * REG_SZ values even if they contain references to other
 685    * environment variables.
 686    */
 687
 688   if (strchr (system_env, '%') == NULL)
 689     {
 690       /* No reference to other variable(s), return value as such. */
 691       return system_env;
 692     }
 693
 694   /* First check how much space we need */
 695   length = ExpandEnvironmentStrings (system_env, dummy, 2);
 696
 697   expanded_env = g_malloc (length);
 698
 699   ExpandEnvironmentStrings (system_env, expanded_env, length);
 700
 701   quark = g_quark_from_string (expanded_env);
 702   g_free (expanded_env);
 703
 704   return g_quark_to_string (quark);
 705 #endif
 706 }
 707
 708 /**
 709  * g_setenv:
 710  * @variable: the environment variable to set, must not contain '='.
 711  * @value: the value for to set the variable to.
 712  * @overwrite: whether to change the variable if it already exists.
 713  *
 714  * Sets an environment variable.
 715  *
 716  * Note that on some systems, the memory used for the variable and its value
 717  * can't be reclaimed later.
 718  *
 719  * Returns: %FALSE if the environment variable couldn't be set.
 720  *
 721  * Since: 2.4
 722  */
 723 gboolean
 724 g_setenv (const gchar *variable,
 725           const gchar *value,
 726           gboolean     overwrite)
 727 {
 728   gint result;
 729 #ifndef HAVE_SETENV
 730   gchar *string;
 731 #endif
 732
 733   g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE);
 734
 735 #ifdef HAVE_SETENV
 736   result = setenv (variable, value, overwrite);
 737 #else
 738   if (!overwrite && g_getenv (variable) != NULL)
 739     return TRUE;
 740
 741   /* This results in a leak when you overwrite existing
 742    * settings. It would be fairly easy to fix this by keeping
 743    * our own parallel array or hash table.
 744    */
 745   string = g_strconcat (variable, "=", value, NULL);
 746   result = putenv (string);
 747 #endif
 748   return result == 0;
 749 }
 750
 751 #ifndef HAVE_UNSETENV
 752 /* According to the Single Unix Specification, environ is not in
 753  * any system header, although unistd.h often declares it.
 754  */
 755 extern char **environ;
 756 #endif
 757
 758 /**
 759  * g_unsetenv:
 760  * @variable: the environment variable to remove, must not contain '='.
 761  *
 762  * Removes an environment variable from the environment.
 763  *
 764  * Note that on some systems, the memory used for the variable and its value
 765  * can't be reclaimed. Furthermore, this function can't be guaranteed to operate in a
 766  * threadsafe way.
 767  *
 768  * Since: 2.4
 769  **/
 770 void
 771 g_unsetenv (const gchar *variable)
 772 {
 773 #ifdef HAVE_UNSETENV
 774   g_return_if_fail (strchr (variable, '=') == NULL);
 775
 776   unsetenv (variable);
 777 #else
 778   int len;
 779   gchar **e, **f;
 780
 781   g_return_if_fail (strchr (variable, '=') == NULL);
 782
 783   len = strlen (variable);
 784
 785   /* Mess directly with the environ array.
 786    * This seems to be the only portable way to do this.
 787    *
 788    * Note that we remove *all* environment entries for
 789    * the variable name, not just the first.
 790    */
 791   e = f = environ;
 792   while (*e != NULL)
 793     {
 794       if (strncmp (*e, variable, len) != 0 || (*e)[len] != '=')
 795         {
 796           *f = *e;
 797           f++;
 798         }
 799       e++;
 800     }
 801   *f = NULL;
 802 #endif
 803 }
 804
 805 G_LOCK_DEFINE_STATIC (g_utils_global);
 806
 807 static  gchar   *g_tmp_dir = NULL;
 808 static  gchar   *g_user_name = NULL;
 809 static  gchar   *g_real_name = NULL;
 810 static  gchar   *g_home_dir = NULL;
 811
 812 /* HOLDS: g_utils_global_lock */
 813 static void
 814 g_get_any_init (void)
 815 {
 816   if (!g_tmp_dir)
 817     {
 818       g_tmp_dir = g_strdup (g_getenv ("TMPDIR"));
 819       if (!g_tmp_dir)
 820         g_tmp_dir = g_strdup (g_getenv ("TMP"));
 821       if (!g_tmp_dir)
 822         g_tmp_dir = g_strdup (g_getenv ("TEMP"));
 823
 824 #ifdef P_tmpdir
 825       if (!g_tmp_dir)
 826         {
 827           gsize k;
 828           g_tmp_dir = g_strdup (P_tmpdir);
 829           k = strlen (g_tmp_dir);
 830           if (k > 1 && G_IS_DIR_SEPARATOR (g_tmp_dir[k - 1]))
 831             g_tmp_dir[k - 1] = '\0';
 832         }
 833 #endif
 834
 835       if (!g_tmp_dir)
 836         {
 837 #ifndef G_OS_WIN32
 838           g_tmp_dir = g_strdup ("/tmp");
 839 #else /* G_OS_WIN32 */
 840           g_tmp_dir = g_strdup ("C:\\");
 841 #endif /* G_OS_WIN32 */
 842         }
 843
 844 #ifdef G_OS_WIN32
 845       /* We check $HOME first for Win32, though it is a last resort for Unix
 846        * where we prefer the results of getpwuid().
 847        */
 848       g_home_dir = g_strdup (g_getenv ("HOME"));
 849
 850       /* In case HOME is Unix-style (it happens), convert it to
 851        * Windows style.
 852        */
 853       if (g_home_dir)
 854         {
 855           gchar *p;
 856           while ((p = strchr (g_home_dir, '/')) != NULL)
 857             *p = '\\';
 858         }
 859
 860       if (!g_home_dir)
 861         {
 862           /* USERPROFILE is probably the closest equivalent to $HOME? */
 863           if (getenv ("USERPROFILE") != NULL)
 864             g_home_dir = g_strdup (g_getenv ("USERPROFILE"));
 865         }
 866
 867       if (!g_home_dir)
 868         {
 869           /* At least at some time, HOMEDRIVE and HOMEPATH were used
 870            * to point to the home directory, I think. But on Windows
 871            * 2000 HOMEDRIVE seems to be equal to SYSTEMDRIVE, and
 872            * HOMEPATH is its root "\"?
 873            */
 874           if (getenv ("HOMEDRIVE") != NULL && getenv ("HOMEPATH") != NULL)
 875             {
 876               gchar *homedrive, *homepath;
 877
 878               homedrive = g_strdup (g_getenv ("HOMEDRIVE"));
 879               homepath = g_strdup (g_getenv ("HOMEPATH"));
 880
 881               g_home_dir = g_strconcat (homedrive, homepath, NULL);
 882               g_free (homedrive);
 883               g_free (homepath);
 884             }
 885         }
 886 #endif /* G_OS_WIN32 */
 887
 888 #ifdef HAVE_PWD_H
 889       {
 890         struct passwd *pw = NULL;
 891         gpointer buffer = NULL;
 892         gint error;
 893
 894 #  if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
 895         struct passwd pwd;
 896 #    ifdef _SC_GETPW_R_SIZE_MAX
 897         /* This reurns the maximum length */
 898         glong bufsize = sysconf (_SC_GETPW_R_SIZE_MAX);
 899
 900         if (bufsize < 0)
 901           bufsize = 64;
 902 #    else /* _SC_GETPW_R_SIZE_MAX */
 903         glong bufsize = 64;
 904 #    endif /* _SC_GETPW_R_SIZE_MAX */
 905
 906         do
 907           {
 908             g_free (buffer);
 909             buffer = g_malloc (bufsize);
 910             errno = 0;
 911
 912 #    ifdef HAVE_POSIX_GETPWUID_R
 913             error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
 914             error = error < 0 ? errno : error;
 915 #    else /* HAVE_NONPOSIX_GETPWUID_R */
 916        /* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
 917 #      if defined(_AIX) || defined(__hpux)
 918             error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
 919             pw = error == 0 ? &pwd : NULL;
 920 #      else /* !_AIX */
 921             pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
 922             error = pw ? 0 : errno;
 923 #      endif /* !_AIX */
 924 #    endif /* HAVE_NONPOSIX_GETPWUID_R */
 925
 926             if (!pw)
 927               {
 928                 /* we bail out prematurely if the user id can't be found
 929                  * (should be pretty rare case actually), or if the buffer
 930                  * should be sufficiently big and lookups are still not
 931                  * successfull.
 932                  */
 933                 if (error == 0 || error == ENOENT)
 934                   {
 935                     g_warning ("getpwuid_r(): failed due to unknown user id (%lu)",
 936                                (gulong) getuid ());
 937                     break;
 938                   }
 939                 if (bufsize > 32 * 1024)
 940                   {
 941                     g_warning ("getpwuid_r(): failed due to: %s.",
 942                                g_strerror (error));
 943                     break;
 944                   }
 945
 946                 bufsize *= 2;
 947               }
 948           }
 949         while (!pw);
 950 #  endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
 951
 952         if (!pw)
 953           {
 954             setpwent ();
 955             pw = getpwuid (getuid ());
 956             endpwent ();
 957           }
 958         if (pw)
 959           {
 960             g_user_name = g_strdup (pw->pw_name);
 961
 962             if (pw->pw_gecos)
 963               {
 964                 gchar **gecos_fields;
 965                 gchar **name_parts;
 966
 967                 /* split the gecos field and substitute '&' */
 968                 gecos_fields = g_strsplit (pw->pw_gecos, ",", 0);
 969                 name_parts = g_strsplit (gecos_fields[0], "&", 0);
 970                 pw->pw_name[0] = g_ascii_toupper (pw->pw_name[0]);
 971                 g_real_name = g_strjoinv (pw->pw_name, name_parts);
 972                 g_strfreev (gecos_fields);
 973                 g_strfreev (name_parts);
 974               }
 975
 976             if (!g_home_dir)
 977               g_home_dir = g_strdup (pw->pw_dir);
 978           }
 979         g_free (buffer);
 980       }
 981
 982 #else /* !HAVE_PWD_H */
 983
 984 #  ifdef G_OS_WIN32
 985       {
 986         guint len = UNLEN+1;
 987         gchar buffer[UNLEN+1];
 988
 989         if (GetUserName ((LPTSTR) buffer, (LPDWORD) &len))
 990           {
 991             g_user_name = g_strdup (buffer);
 992             g_real_name = g_strdup (buffer);
 993           }
 994       }
 995 #  endif /* G_OS_WIN32 */
 996
 997 #endif /* !HAVE_PWD_H */
 998
 999       if (!g_home_dir)
1000         g_home_dir = g_strdup (g_getenv ("HOME"));
1001
1002 #ifdef __EMX__
1003       /* change '\\' in %HOME% to '/' */
1004       g_strdelimit (g_home_dir, "\\",'/');
1005 #endif
1006       if (!g_user_name)
1007         g_user_name = g_strdup ("somebody");
1008       if (!g_real_name)
1009         g_real_name = g_strdup ("Unknown");
1010     }
1011 }
1012
1013 G_CONST_RETURN gchar*
1014 g_get_user_name (void)
1015 {
1016   G_LOCK (g_utils_global);
1017   if (!g_tmp_dir)
1018     g_get_any_init ();
1019   G_UNLOCK (g_utils_global);
1020
1021   return g_user_name;
1022 }
1023
1024 G_CONST_RETURN gchar*
1025 g_get_real_name (void)
1026 {
1027   G_LOCK (g_utils_global);
1028   if (!g_tmp_dir)
1029     g_get_any_init ();
1030   G_UNLOCK (g_utils_global);
1031
1032   return g_real_name;
1033 }
1034
1035 /* Return the home directory of the user. If there is a HOME
1036  * environment variable, its value is returned, otherwise use some
1037  * system-dependent way of finding it out. If no home directory can be
1038  * deduced, return NULL.
1039  */
1040
1041 G_CONST_RETURN gchar*
1042 g_get_home_dir (void)
1043 {
1044   G_LOCK (g_utils_global);
1045   if (!g_tmp_dir)
1046     g_get_any_init ();
1047   G_UNLOCK (g_utils_global);
1048
1049   return g_home_dir;
1050 }
1051
1052 /* Return a directory to be used to store temporary files. This is the
1053  * value of the TMPDIR, TMP or TEMP environment variables (they are
1054  * checked in that order). If none of those exist, use P_tmpdir from
1055  * stdio.h.  If that isn't defined, return "/tmp" on POSIXly systems,
1056  * and C:\ on Windows.
1057  */
1058
1059 G_CONST_RETURN gchar*
1060 g_get_tmp_dir (void)
1061 {
1062   G_LOCK (g_utils_global);
1063   if (!g_tmp_dir)
1064     g_get_any_init ();
1065   G_UNLOCK (g_utils_global);
1066
1067   return g_tmp_dir;
1068 }
1069
1070 G_LOCK_DEFINE_STATIC (g_prgname);
1071 static gchar *g_prgname = NULL;
1072
1073 gchar*
1074 g_get_prgname (void)
1075 {
1076   gchar* retval;
1077
1078   G_LOCK (g_prgname);
1079   retval = g_prgname;
1080   G_UNLOCK (g_prgname);
1081
1082   return retval;
1083 }
1084
1085 void
1086 g_set_prgname (const gchar *prgname)
1087 {
1088   G_LOCK (g_prgname);
1089   g_free (g_prgname);
1090   g_prgname = g_strdup (prgname);
1091   G_UNLOCK (g_prgname);
1092 }
1093
1094 G_LOCK_DEFINE_STATIC (g_application_name);
1095 static gchar *g_application_name = NULL;
1096
1097 /**
1098  * g_get_application_name:
1099  *
1100  * Gets a human-readable name for the application, as set by
1101  * g_set_application_name(). This name should be localized if
1102  * possible, and is intended for display to the user.  Contrast with
1103  * g_get_prgname(), which gets a non-localized name. If
1104  * g_set_application_name() has not been called, returns the result of
1105  * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
1106  * been called).
1107  *
1108  * Return value: human-readable application name. may return %NULL
1109  *
1110  * Since: 2.2
1111  **/
1112 G_CONST_RETURN gchar*
1113 g_get_application_name (void)
1114 {
1115   gchar* retval;
1116
1117   G_LOCK (g_application_name);
1118   retval = g_application_name;
1119   G_UNLOCK (g_application_name);
1120
1121   if (retval == NULL)
1122     return g_get_prgname ();
1123
1124   return retval;
1125 }
1126
1127 /**
1128  * g_set_application_name:
1129  * @application_name: localized name of the application
1130  *
1131  * Sets a human-readable name for the application. This name should be
1132  * localized if possible, and is intended for display to the user.
1133  * Contrast with g_set_prgname(), which sets a non-localized name.
1134  * g_set_prgname() will be called automatically by gtk_init(),
1135  * but g_set_application_name() will not.
1136  *
1137  * Note that for thread safety reasons, this function can only
1138  * be called once.
1139  *
1140  * The application name will be used in contexts such as error messages,
1141  * or when displaying an application's name in the task list.
1142  *
1143  **/
1144 void
1145 g_set_application_name (const gchar *application_name)
1146 {
1147   gboolean already_set = FALSE;
1148
1149   G_LOCK (g_application_name);
1150   if (g_application_name)
1151     already_set = TRUE;
1152   else
1153     g_application_name = g_strdup (application_name);
1154   G_UNLOCK (g_application_name);
1155
1156   if (already_set)
1157     g_warning ("g_set_application() name called multiple times");
1158 }
1159
1160 guint
1161 g_direct_hash (gconstpointer v)
1162 {
1163   return GPOINTER_TO_UINT (v);
1164 }
1165
1166 gboolean
1167 g_direct_equal (gconstpointer v1,
1168                 gconstpointer v2)
1169 {
1170   return v1 == v2;
1171 }
1172
1173 gboolean
1174 g_int_equal (gconstpointer v1,
1175              gconstpointer v2)
1176 {
1177   return *((const gint*) v1) == *((const gint*) v2);
1178 }
1179
1180 guint
1181 g_int_hash (gconstpointer v)
1182 {
1183   return *(const gint*) v;
1184 }
1185
1186 /**
1187  * g_nullify_pointer:
1188  * @nullify_location: the memory address of the pointer.
1189  *
1190  * Set the pointer at the specified location to %NULL.
1191  **/
1192 void
1193 g_nullify_pointer (gpointer *nullify_location)
1194 {
1195   g_return_if_fail (nullify_location != NULL);
1196
1197   *nullify_location = NULL;
1198 }
1199
1200 /**
1201  * g_get_codeset:
1202  *
1203  * Get the codeset for the current locale.
1204  *
1205  * Return value: a newly allocated string containing the name
1206  * of the codeset. This string must be freed with g_free().
1207  **/
1208 gchar *
1209 g_get_codeset (void)
1210 {
1211 #ifdef HAVE_CODESET
1212   char *result = nl_langinfo (CODESET);
1213   return g_strdup (result);
1214 #else
1215 #ifdef G_PLATFORM_WIN32
1216   return g_strdup_printf ("CP%d", GetACP ());
1217 #else
1218   /* FIXME: Do something more intelligent based on setlocale (LC_CTYPE, NULL)
1219    */
1220   return g_strdup ("ISO-8859-1");
1221 #endif
1222 #endif
1223 }
1224
1225 #ifdef ENABLE_NLS
1226
1227 #include <libintl.h>
1228
1229 #ifdef G_PLATFORM_WIN32
1230
1231 G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)
1232
1233 static const gchar *
1234 _glib_get_locale_dir (void)
1235 {
1236   static const gchar *cache = NULL;
1237   if (cache == NULL)
1238     cache = g_win32_get_package_installation_subdirectory
1239       (GETTEXT_PACKAGE, dll_name, "lib\\locale");
1240
1241   return cache;
1242 }
1243
1244 #undef GLIB_LOCALE_DIR
1245 #define GLIB_LOCALE_DIR _glib_get_locale_dir ()
1246
1247 #endif /* G_PLATFORM_WIN32 */
1248
1249 G_CONST_RETURN gchar *
1250 _glib_gettext (const gchar *str)
1251 {
1252   static gboolean _glib_gettext_initialized = FALSE;
1253
1254   if (!_glib_gettext_initialized)
1255     {
1256       bindtextdomain(GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
1257 #    ifdef HAVE_BIND_TEXTDOMAIN_CODESET
1258       bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1259 #    endif
1260       _glib_gettext_initialized = TRUE;
1261     }
1262
1263   return dgettext (GETTEXT_PACKAGE, str);
1264 }
1265
1266 #endif /* ENABLE_NLS */