/* GLIB - Library of useful routines for C programming * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* * Modified by the GLib Team and others 1997-1999. See the AUTHORS * file for a list of people on the GLib Team. See the ChangeLog * files for a list of changes. These files are distributed with * GLib at ftp://ftp.gtk.org/pub/gtk/. */ /* * MT safe */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include /* For tolower() */ #if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL) #include #endif #include "glib.h" /* do not include in this place since it * inteferes with g_strsignal() on some OSes */ typedef union _GDoubleIEEE754 GDoubleIEEE754; #define G_IEEE754_DOUBLE_BIAS (1023) /* multiply with base2 exponent to get base10 exponent (nomal numbers) */ #define G_LOG_2_BASE_10 (0.30102999566398119521) #if G_BYTE_ORDER == G_LITTLE_ENDIAN union _GDoubleIEEE754 { gdouble v_double; struct { guint mantissa_low : 32; guint mantissa_high : 20; guint biased_exponent : 11; guint sign : 1; } mpn; }; #elif G_BYTE_ORDER == G_BIG_ENDIAN union _GDoubleIEEE754 { gdouble v_double; struct { guint sign : 1; guint biased_exponent : 11; guint mantissa_high : 20; guint mantissa_low : 32; } mpn; }; #else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */ #error unknown ENDIAN type #endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */ gchar* g_strdup (const gchar *str) { gchar *new_str; if (str) { new_str = g_new (char, strlen (str) + 1); strcpy (new_str, str); } else new_str = NULL; return new_str; } gpointer g_memdup (gconstpointer mem, guint byte_size) { gpointer new_mem; if (mem) { new_mem = g_malloc (byte_size); memcpy (new_mem, mem, byte_size); } else new_mem = NULL; return new_mem; } gchar* g_strndup (const gchar *str, guint n) { gchar *new_str; if (str) { new_str = g_new (gchar, n + 1); strncpy (new_str, str, n); new_str[n] = '\0'; } else new_str = NULL; return new_str; } gchar* g_strnfill (guint length, gchar fill_char) { register gchar *str, *s, *end; str = g_new (gchar, length + 1); s = str; end = str + length; while (s < end) *(s++) = fill_char; *s = 0; return str; } gchar* g_strdup_vprintf (const gchar *format, va_list args1) { gchar *buffer; va_list args2; G_VA_COPY (args2, args1); buffer = g_new (gchar, g_printf_string_upper_bound (format, args1)); vsprintf (buffer, format, args2); va_end (args2); return buffer; } gchar* g_strdup_printf (const gchar *format, ...) { gchar *buffer; va_list args; va_start (args, format); buffer = g_strdup_vprintf (format, args); va_end (args); return buffer; } gchar* g_strconcat (const gchar *string1, ...) { guint l; va_list args; gchar *s; gchar *concat; g_return_val_if_fail (string1 != NULL, NULL); l = 1 + strlen (string1); va_start (args, string1); s = va_arg (args, gchar*); while (s) { l += strlen (s); s = va_arg (args, gchar*); } va_end (args); concat = g_new (gchar, l); concat[0] = 0; strcat (concat, string1); va_start (args, string1); s = va_arg (args, gchar*); while (s) { strcat (concat, s); s = va_arg (args, gchar*); } va_end (args); return concat; } gdouble g_strtod (const gchar *nptr, gchar **endptr) { gchar *fail_pos_1; gchar *fail_pos_2; gdouble val_1; gdouble val_2 = 0; g_return_val_if_fail (nptr != NULL, 0); fail_pos_1 = NULL; fail_pos_2 = NULL; val_1 = strtod (nptr, &fail_pos_1); if (fail_pos_1 && fail_pos_1[0] != 0) { gchar *old_locale; old_locale = g_strdup (setlocale (LC_NUMERIC, NULL)); setlocale (LC_NUMERIC, "C"); val_2 = strtod (nptr, &fail_pos_2); setlocale (LC_NUMERIC, old_locale); g_free (old_locale); } if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2) { if (endptr) *endptr = fail_pos_1; return val_1; } else { if (endptr) *endptr = fail_pos_2; return val_2; } } gchar* g_strerror (gint errnum) { static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT; char *msg; #ifdef HAVE_STRERROR return strerror (errnum); #elif NO_SYS_ERRLIST switch (errnum) { #ifdef E2BIG case E2BIG: return "argument list too long"; #endif #ifdef EACCES case EACCES: return "permission denied"; #endif #ifdef EADDRINUSE case EADDRINUSE: return "address already in use"; #endif #ifdef EADDRNOTAVAIL case EADDRNOTAVAIL: return "can't assign requested address"; #endif #ifdef EADV case EADV: return "advertise error"; #endif #ifdef EAFNOSUPPORT case EAFNOSUPPORT: return "address family not supported by protocol family"; #endif #ifdef EAGAIN case EAGAIN: return "try again"; #endif #ifdef EALIGN case EALIGN: return "EALIGN"; #endif #ifdef EALREADY case EALREADY: return "operation already in progress"; #endif #ifdef EBADE case EBADE: return "bad exchange descriptor"; #endif #ifdef EBADF case EBADF: return "bad file number"; #endif #ifdef EBADFD case EBADFD: return "file descriptor in bad state"; #endif #ifdef EBADMSG case EBADMSG: return "not a data message"; #endif #ifdef EBADR case EBADR: return "bad request descriptor"; #endif #ifdef EBADRPC case EBADRPC: return "RPC structure is bad"; #endif #ifdef EBADRQC case EBADRQC: return "bad request code"; #endif #ifdef EBADSLT case EBADSLT: return "invalid slot"; #endif #ifdef EBFONT case EBFONT: return "bad font file format"; #endif #ifdef EBUSY case EBUSY: return "mount device busy"; #endif #ifdef ECHILD case ECHILD: return "no children"; #endif #ifdef ECHRNG case ECHRNG: return "channel number out of range"; #endif #ifdef ECOMM case ECOMM: return "communication error on send"; #endif #ifdef ECONNABORTED case ECONNABORTED: return "software caused connection abort"; #endif #ifdef ECONNREFUSED case ECONNREFUSED: return "connection refused"; #endif #ifdef ECONNRESET case ECONNRESET: return "connection reset by peer"; #endif #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK)) case EDEADLK: return "resource deadlock avoided"; #endif #ifdef EDEADLOCK case EDEADLOCK: return "resource deadlock avoided"; #endif #ifdef EDESTADDRREQ case EDESTADDRREQ: return "destination address required"; #endif #ifdef EDIRTY case EDIRTY: return "mounting a dirty fs w/o force"; #endif #ifdef EDOM case EDOM: return "math argument out of range"; #endif #ifdef EDOTDOT case EDOTDOT: return "cross mount point"; #endif #ifdef EDQUOT case EDQUOT: return "disk quota exceeded"; #endif #ifdef EDUPPKG case EDUPPKG: return "duplicate package name"; #endif #ifdef EEXIST case EEXIST: return "file already exists"; #endif #ifdef EFAULT case EFAULT: return "bad address in system call argument"; #endif #ifdef EFBIG case EFBIG: return "file too large"; #endif #ifdef EHOSTDOWN case EHOSTDOWN: return "host is down"; #endif #ifdef EHOSTUNREACH case EHOSTUNREACH: return "host is unreachable"; #endif #ifdef EIDRM case EIDRM: return "identifier removed"; #endif #ifdef EINIT case EINIT: return "initialization error"; #endif #ifdef EINPROGRESS case EINPROGRESS: return "operation now in progress"; #endif #ifdef EINTR case EINTR: return "interrupted system call"; #endif #ifdef EINVAL case EINVAL: return "invalid argument"; #endif #ifdef EIO case EIO: return "I/O error"; #endif #ifdef EISCONN case EISCONN: return "socket is already connected"; #endif #ifdef EISDIR case EISDIR: return "illegal operation on a directory"; #endif #ifdef EISNAME case EISNAM: return "is a name file"; #endif #ifdef ELBIN case ELBIN: return "ELBIN"; #endif #ifdef EL2HLT case EL2HLT: return "level 2 halted"; #endif #ifdef EL2NSYNC case EL2NSYNC: return "level 2 not synchronized"; #endif #ifdef EL3HLT case EL3HLT: return "level 3 halted"; #endif #ifdef EL3RST case EL3RST: return "level 3 reset"; #endif #ifdef ELIBACC case ELIBACC: return "can not access a needed shared library"; #endif #ifdef ELIBBAD case ELIBBAD: return "accessing a corrupted shared library"; #endif #ifdef ELIBEXEC case ELIBEXEC: return "can not exec a shared library directly"; #endif #ifdef ELIBMAX case ELIBMAX: return "attempting to link in more shared libraries than system limit"; #endif #ifdef ELIBSCN case ELIBSCN: return ".lib section in a.out corrupted"; #endif #ifdef ELNRNG case ELNRNG: return "link number out of range"; #endif #ifdef ELOOP case ELOOP: return "too many levels of symbolic links"; #endif #ifdef EMFILE case EMFILE: return "too many open files"; #endif #ifdef EMLINK case EMLINK: return "too many links"; #endif #ifdef EMSGSIZE case EMSGSIZE: return "message too long"; #endif #ifdef EMULTIHOP case EMULTIHOP: return "multihop attempted"; #endif #ifdef ENAMETOOLONG case ENAMETOOLONG: return "file name too long"; #endif #ifdef ENAVAIL case ENAVAIL: return "not available"; #endif #ifdef ENET case ENET: return "ENET"; #endif #ifdef ENETDOWN case ENETDOWN: return "network is down"; #endif #ifdef ENETRESET case ENETRESET: return "network dropped connection on reset"; #endif #ifdef ENETUNREACH case ENETUNREACH: return "network is unreachable"; #endif #ifdef ENFILE case ENFILE: return "file table overflow"; #endif #ifdef ENOANO case ENOANO: return "anode table overflow"; #endif #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR)) case ENOBUFS: return "no buffer space available"; #endif #ifdef ENOCSI case ENOCSI: return "no CSI structure available"; #endif #ifdef ENODATA case ENODATA: return "no data available"; #endif #ifdef ENODEV case ENODEV: return "no such device"; #endif #ifdef ENOENT case ENOENT: return "no such file or directory"; #endif #ifdef ENOEXEC case ENOEXEC: return "exec format error"; #endif #ifdef ENOLCK case ENOLCK: return "no locks available"; #endif #ifdef ENOLINK case ENOLINK: return "link has be severed"; #endif #ifdef ENOMEM case ENOMEM: return "not enough memory"; #endif #ifdef ENOMSG case ENOMSG: return "no message of desired type"; #endif #ifdef ENONET case ENONET: return "machine is not on the network"; #endif #ifdef ENOPKG case ENOPKG: return "package not installed"; #endif #ifdef ENOPROTOOPT case ENOPROTOOPT: return "bad proocol option"; #endif #ifdef ENOSPC case ENOSPC: return "no space left on device"; #endif #ifdef ENOSR case ENOSR: return "out of stream resources"; #endif #ifdef ENOSTR case ENOSTR: return "not a stream device"; #endif #ifdef ENOSYM case ENOSYM: return "unresolved symbol name"; #endif #ifdef ENOSYS case ENOSYS: return "function not implemented"; #endif #ifdef ENOTBLK case ENOTBLK: return "block device required"; #endif #ifdef ENOTCONN case ENOTCONN: return "socket is not connected"; #endif #ifdef ENOTDIR case ENOTDIR: return "not a directory"; #endif #ifdef ENOTEMPTY case ENOTEMPTY: return "directory not empty"; #endif #ifdef ENOTNAM case ENOTNAM: return "not a name file"; #endif #ifdef ENOTSOCK case ENOTSOCK: return "socket operation on non-socket"; #endif #ifdef ENOTTY case ENOTTY: return "inappropriate device for ioctl"; #endif #ifdef ENOTUNIQ case ENOTUNIQ: return "name not unique on network"; #endif #ifdef ENXIO case ENXIO: return "no such device or address"; #endif #ifdef EOPNOTSUPP case EOPNOTSUPP: return "operation not supported on socket"; #endif #ifdef EPERM case EPERM: return "not owner"; #endif #ifdef EPFNOSUPPORT case EPFNOSUPPORT: return "protocol family not supported"; #endif #ifdef EPIPE case EPIPE: return "broken pipe"; #endif #ifdef EPROCLIM case EPROCLIM: return "too many processes"; #endif #ifdef EPROCUNAVAIL case EPROCUNAVAIL: return "bad procedure for program"; #endif #ifdef EPROGMISMATCH case EPROGMISMATCH: return "program version wrong"; #endif #ifdef EPROGUNAVAIL case EPROGUNAVAIL: return "RPC program not available"; #endif #ifdef EPROTO case EPROTO: return "protocol error"; #endif #ifdef EPROTONOSUPPORT case EPROTONOSUPPORT: return "protocol not suppored"; #endif #ifdef EPROTOTYPE case EPROTOTYPE: return "protocol wrong type for socket"; #endif #ifdef ERANGE case ERANGE: return "math result unrepresentable"; #endif #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED)) case EREFUSED: return "EREFUSED"; #endif #ifdef EREMCHG case EREMCHG: return "remote address changed"; #endif #ifdef EREMDEV case EREMDEV: return "remote device"; #endif #ifdef EREMOTE case EREMOTE: return "pathname hit remote file system"; #endif #ifdef EREMOTEIO case EREMOTEIO: return "remote i/o error"; #endif #ifdef EREMOTERELEASE case EREMOTERELEASE: return "EREMOTERELEASE"; #endif #ifdef EROFS case EROFS: return "read-only file system"; #endif #ifdef ERPCMISMATCH case ERPCMISMATCH: return "RPC version is wrong"; #endif #ifdef ERREMOTE case ERREMOTE: return "object is remote"; #endif #ifdef ESHUTDOWN case ESHUTDOWN: return "can't send afer socket shutdown"; #endif #ifdef ESOCKTNOSUPPORT case ESOCKTNOSUPPORT: return "socket type not supported"; #endif #ifdef ESPIPE case ESPIPE: return "invalid seek"; #endif #ifdef ESRCH case ESRCH: return "no such process"; #endif #ifdef ESRMNT case ESRMNT: return "srmount error"; #endif #ifdef ESTALE case ESTALE: return "stale remote file handle"; #endif #ifdef ESUCCESS case ESUCCESS: return "Error 0"; #endif #ifdef ETIME case ETIME: return "timer expired"; #endif #ifdef ETIMEDOUT case ETIMEDOUT: return "connection timed out"; #endif #ifdef ETOOMANYREFS case ETOOMANYREFS: return "too many references: can't splice"; #endif #ifdef ETXTBSY case ETXTBSY: return "text file or pseudo-device busy"; #endif #ifdef EUCLEAN case EUCLEAN: return "structure needs cleaning"; #endif #ifdef EUNATCH case EUNATCH: return "protocol driver not attached"; #endif #ifdef EUSERS case EUSERS: return "too many users"; #endif #ifdef EVERSION case EVERSION: return "version mismatch"; #endif #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN)) case EWOULDBLOCK: return "operation would block"; #endif #ifdef EXDEV case EXDEV: return "cross-domain link"; #endif #ifdef EXFULL case EXFULL: return "message tables full"; #endif } #else /* NO_SYS_ERRLIST */ extern int sys_nerr; extern char *sys_errlist[]; if ((errnum > 0) && (errnum <= sys_nerr)) return sys_errlist [errnum]; #endif /* NO_SYS_ERRLIST */ msg = g_static_private_get (&msg_private); if (!msg) { msg = g_new (gchar, 64); g_static_private_set (&msg_private, msg, g_free); } sprintf (msg, "unknown error (%d)", errnum); return msg; } gchar* g_strsignal (gint signum) { static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT; char *msg; #ifdef HAVE_STRSIGNAL extern char *strsignal (int sig); return strsignal (signum); #elif NO_SYS_SIGLIST switch (signum) { #ifdef SIGHUP case SIGHUP: return "Hangup"; #endif #ifdef SIGINT case SIGINT: return "Interrupt"; #endif #ifdef SIGQUIT case SIGQUIT: return "Quit"; #endif #ifdef SIGILL case SIGILL: return "Illegal instruction"; #endif #ifdef SIGTRAP case SIGTRAP: return "Trace/breakpoint trap"; #endif #ifdef SIGABRT case SIGABRT: return "IOT trap/Abort"; #endif #ifdef SIGBUS case SIGBUS: return "Bus error"; #endif #ifdef SIGFPE case SIGFPE: return "Floating point exception"; #endif #ifdef SIGKILL case SIGKILL: return "Killed"; #endif #ifdef SIGUSR1 case SIGUSR1: return "User defined signal 1"; #endif #ifdef SIGSEGV case SIGSEGV: return "Segmentation fault"; #endif #ifdef SIGUSR2 case SIGUSR2: return "User defined signal 2"; #endif #ifdef SIGPIPE case SIGPIPE: return "Broken pipe"; #endif #ifdef SIGALRM case SIGALRM: return "Alarm clock"; #endif #ifdef SIGTERM case SIGTERM: return "Terminated"; #endif #ifdef SIGSTKFLT case SIGSTKFLT: return "Stack fault"; #endif #ifdef SIGCHLD case SIGCHLD: return "Child exited"; #endif #ifdef SIGCONT case SIGCONT: return "Continued"; #endif #ifdef SIGSTOP case SIGSTOP: return "Stopped (signal)"; #endif #ifdef SIGTSTP case SIGTSTP: return "Stopped"; #endif #ifdef SIGTTIN case SIGTTIN: return "Stopped (tty input)"; #endif #ifdef SIGTTOU case SIGTTOU: return "Stopped (tty output)"; #endif #ifdef SIGURG case SIGURG: return "Urgent condition"; #endif #ifdef SIGXCPU case SIGXCPU: return "CPU time limit exceeded"; #endif #ifdef SIGXFSZ case SIGXFSZ: return "File size limit exceeded"; #endif #ifdef SIGVTALRM case SIGVTALRM: return "Virtual time alarm"; #endif #ifdef SIGPROF case SIGPROF: return "Profile signal"; #endif #ifdef SIGWINCH case SIGWINCH: return "Window size changed"; #endif #ifdef SIGIO case SIGIO: return "Possible I/O"; #endif #ifdef SIGPWR case SIGPWR: return "Power failure"; #endif #ifdef SIGUNUSED case SIGUNUSED: return "Unused signal"; #endif } #else /* NO_SYS_SIGLIST */ #ifdef NO_SYS_SIGLIST_DECL extern char *sys_siglist[]; /*(see Tue Jan 19 00:44:24 1999 in changelog)*/ #endif return (char*) /* this function should return const --josh */ sys_siglist [signum]; #endif /* NO_SYS_SIGLIST */ msg = g_static_private_get (&msg_private); if (!msg) { msg = g_new (gchar, 64); g_static_private_set (&msg_private, msg, g_free); } sprintf (msg, "unknown signal (%d)", signum); return msg; } typedef struct { guint min_width; guint precision; gboolean alternate_format, zero_padding, adjust_left, locale_grouping; gboolean add_space, add_sign, possible_sign, seen_precision; gboolean mod_half, mod_long, mod_extra_long; } PrintfArgSpec; guint g_printf_string_upper_bound (const gchar* format, va_list args) { static const gboolean honour_longs = SIZEOF_LONG > 4 || SIZEOF_VOID_P > 4; guint len = 1; if (!format) return len; while (*format) { register gchar c = *format++; if (c != '%') len += 1; else /* (c == '%') */ { PrintfArgSpec spec = { 0, }; gboolean seen_l = FALSE, conv_done = FALSE; guint conv_len = 0; const gchar *spec_start = format; do { c = *format++; switch (c) { GDoubleIEEE754 u_double; guint v_uint; gint v_int; const gchar *v_string; /* beware of positional parameters */ case '$': g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to handle positional parameters (%%n$)"); len += 1024; /* try adding some safety padding */ break; /* parse flags */ case '#': spec.alternate_format = TRUE; break; case '0': spec.zero_padding = TRUE; break; case '-': spec.adjust_left = TRUE; break; case ' ': spec.add_space = TRUE; break; case '+': spec.add_sign = TRUE; break; case '\'': spec.locale_grouping = TRUE; break; /* parse output size specifications */ case '.': spec.seen_precision = TRUE; break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': v_uint = c - '0'; c = *format; while (c >= '0' && c <= '9') { format++; v_uint = v_uint * 10 + c - '0'; c = *format; } if (spec.seen_precision) spec.precision = MAX (spec.precision, v_uint); else spec.min_width = MAX (spec.min_width, v_uint); break; case '*': v_int = va_arg (args, int); if (spec.seen_precision) { /* forget about negative precision */ if (v_int >= 0) spec.precision = MAX (spec.precision, v_int); } else { if (v_int < 0) { v_int = - v_int; spec.adjust_left = TRUE; } spec.min_width = MAX (spec.min_width, v_int); } break; /* parse type modifiers */ case 'h': spec.mod_half = TRUE; break; case 'l': if (!seen_l) { spec.mod_long = TRUE; seen_l = TRUE; break; } /* else, fall through */ case 'L': case 'q': spec.mod_long = TRUE; spec.mod_extra_long = TRUE; break; case 'z': case 'Z': #if GLIB_SIZEOF_SIZE_T > 4 spec.mod_long = TRUE; spec.mod_extra_long = TRUE; #endif /* GLIB_SIZEOF_SIZE_T > 4 */ break; case 't': #if GLIB_SIZEOF_PTRDIFF_T > 4 spec.mod_long = TRUE; spec.mod_extra_long = TRUE; #endif /* GLIB_SIZEOF_PTRDIFF_T > 4 */ break; case 'j': #if GLIB_SIZEOF_INTMAX_T > 4 spec.mod_long = TRUE; spec.mod_extra_long = TRUE; #endif /* GLIB_SIZEOF_INTMAX_T > 4 */ break; /* parse output conversions */ case '%': conv_len += 1; break; case 'O': case 'D': case 'I': case 'U': /* some C libraries feature long variants for these as well? */ spec.mod_long = TRUE; /* fall through */ case 'o': conv_len += 2; /* fall through */ case 'd': case 'i': conv_len += 1; /* sign */ /* fall through */ case 'u': conv_len += 4; /* fall through */ case 'x': case 'X': spec.possible_sign = TRUE; conv_len += 10; if (spec.mod_long && honour_longs) conv_len *= 2; if (spec.mod_extra_long) conv_len *= 2; if (spec.mod_extra_long) { #ifdef G_HAVE_GINT64 (void) va_arg (args, gint64); #else /* !G_HAVE_GINT64 */ (void) va_arg (args, long); #endif /* !G_HAVE_GINT64 */ } else if (spec.mod_long) (void) va_arg (args, long); else (void) va_arg (args, int); break; case 'A': case 'a': /* 0x */ conv_len += 2; /* fall through */ case 'g': case 'G': case 'e': case 'E': case 'f': spec.possible_sign = TRUE; /* n . dddddddddddddddddddddddd E +- eeee */ conv_len += 1 + 1 + MAX (24, spec.precision) + 1 + 1 + 4; if (spec.mod_extra_long) g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to handle long double, collecting double only"); #ifdef HAVE_LONG_DOUBLE #error need to implement special handling for long double #endif u_double.v_double = va_arg (args, double); /* %f can expand up to all significant digits before '.' (308) */ if (c == 'f' && u_double.mpn.biased_exponent > 0 && u_double.mpn.biased_exponent < 2047) { gint exp = u_double.mpn.biased_exponent; exp -= G_IEEE754_DOUBLE_BIAS; exp = exp * G_LOG_2_BASE_10 + 1; conv_len += exp; } /* some printf() implementations require extra padding for rounding */ conv_len += 2; /* we can't really handle locale specific grouping here */ if (spec.locale_grouping) conv_len *= 2; break; case 'C': spec.mod_long = TRUE; /* fall through */ case 'c': conv_len += spec.mod_long ? MB_LEN_MAX : 1; (void) va_arg (args, int); break; case 'S': spec.mod_long = TRUE; /* fall through */ case 's': v_string = va_arg (args, char*); if (!v_string) conv_len += 8; /* hold "(null)" */ else if (spec.seen_precision) conv_len += spec.precision; else conv_len += strlen (v_string); conv_done = TRUE; if (spec.mod_long) { g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to handle wide char strings"); len += 1024; /* try adding some safety padding */ } break; case 'P': /* do we actually need this? */ /* fall through */ case 'p': spec.alternate_format = TRUE; conv_len += 10; if (honour_longs) conv_len *= 2; /* fall through */ case 'n': conv_done = TRUE; (void) va_arg (args, void*); break; case 'm': /* there's not much we can do to be clever */ v_string = g_strerror (errno); v_uint = v_string ? strlen (v_string) : 0; conv_len += MAX (256, v_uint); break; /* handle invalid cases */ case '\000': /* no conversion specification, bad bad */ conv_len += format - spec_start; break; default: g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to handle `%c' while parsing format", c); break; } conv_done |= conv_len > 0; } while (!conv_done); /* handle width specifications */ conv_len = MAX (conv_len, MAX (spec.precision, spec.min_width)); /* handle flags */ conv_len += spec.alternate_format ? 2 : 0; conv_len += (spec.add_space || spec.add_sign || spec.possible_sign); /* finally done */ len += conv_len; } /* else (c == '%') */ } /* while (*format) */ return len; } void g_strdown (gchar *string) { register guchar *s; g_return_if_fail (string != NULL); s = string; while (*s) { *s = tolower (*s); s++; } } void g_strup (gchar *string) { register guchar *s; g_return_if_fail (string != NULL); s = string; while (*s) { *s = toupper (*s); s++; } } void g_strreverse (gchar *string) { g_return_if_fail (string != NULL); if (*string) { register gchar *h, *t; h = string; t = string + strlen (string) - 1; while (h < t) { register gchar c; c = *h; *h = *t; h++; *t = c; t--; } } } gint g_strcasecmp (const gchar *s1, const gchar *s2) { #ifdef HAVE_STRCASECMP g_return_val_if_fail (s1 != NULL, 0); g_return_val_if_fail (s2 != NULL, 0); return strcasecmp (s1, s2); #else gint c1, c2; g_return_val_if_fail (s1 != NULL, 0); g_return_val_if_fail (s2 != NULL, 0); while (*s1 && *s2) { /* According to A. Cox, some platforms have islower's that * don't work right on non-uppercase */ c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1; c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2; if (c1 != c2) return (c1 - c2); s1++; s2++; } return (((gint)(guchar) *s1) - ((gint)(guchar) *s2)); #endif } gint g_strncasecmp (const gchar *s1, const gchar *s2, guint n) { #ifdef HAVE_STRNCASECMP return strncasecmp (s1, s2, n); #else gint c1, c2; g_return_val_if_fail (s1 != NULL, 0); g_return_val_if_fail (s2 != NULL, 0); while (n && *s1 && *s2) { n -= 1; /* According to A. Cox, some platforms have islower's that * don't work right on non-uppercase */ c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1; c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2; if (c1 != c2) return (c1 - c2); s1++; s2++; } if (n) return (((gint) (guchar) *s1) - ((gint) (guchar) *s2)); else return 0; #endif } gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delim) { register gchar *c; g_return_val_if_fail (string != NULL, NULL); if (!delimiters) delimiters = G_STR_DELIMITERS; for (c = string; *c; c++) { if (strchr (delimiters, *c)) *c = new_delim; } return string; } gchar* g_strescape (gchar *string) { gchar *q; gchar *escaped; guint backslashes = 0; gchar *p = string; g_return_val_if_fail (string != NULL, NULL); while (*p != '\000') backslashes += (*p++ == '\\'); if (!backslashes) return g_strdup (string); escaped = g_new (gchar, strlen (string) + backslashes + 1); p = string; q = escaped; while (*p != '\000') { if (*p == '\\') *q++ = '\\'; *q++ = *p++; } *q = '\000'; return escaped; } /* blame Elliot for these next five routines */ gchar* g_strchug (gchar *string) { guchar *start; g_return_val_if_fail (string != NULL, NULL); for (start = string; *start && isspace (*start); start++) ; g_memmove(string, start, strlen(start) + 1); return string; } gchar* g_strchomp (gchar *string) { gchar *s; g_return_val_if_fail (string != NULL, NULL); if (!*string) return string; for (s = string + strlen (string) - 1; s >= string && isspace ((guchar)*s); s--) *s = '\0'; return string; } gchar** g_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens) { GSList *string_list = NULL, *slist; gchar **str_array, *s; guint i, n = 1; g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (delimiter != NULL, NULL); if (max_tokens < 1) max_tokens = G_MAXINT; s = strstr (string, delimiter); if (s) { guint delimiter_len = strlen (delimiter); do { guint len; gchar *new_string; len = s - string; new_string = g_new (gchar, len + 1); strncpy (new_string, string, len); new_string[len] = 0; string_list = g_slist_prepend (string_list, new_string); n++; string = s + delimiter_len; s = strstr (string, delimiter); } while (--max_tokens && s); } if (*string) { n++; string_list = g_slist_prepend (string_list, g_strdup (string)); } str_array = g_new (gchar*, n); i = n - 1; str_array[i--] = NULL; for (slist = string_list; slist; slist = slist->next) str_array[i--] = slist->data; g_slist_free (string_list); return str_array; } void g_strfreev (gchar **str_array) { if (str_array) { int i; for(i = 0; str_array[i] != NULL; i++) g_free(str_array[i]); g_free (str_array); } } gchar* g_strjoinv (const gchar *separator, gchar **str_array) { gchar *string; g_return_val_if_fail (str_array != NULL, NULL); if (separator == NULL) separator = ""; if (*str_array) { guint i, len; guint separator_len; separator_len = strlen (separator); len = 1 + strlen (str_array[0]); for(i = 1; str_array[i] != NULL; i++) len += separator_len + strlen(str_array[i]); string = g_new (gchar, len); *string = 0; strcat (string, *str_array); for (i = 1; str_array[i] != NULL; i++) { strcat (string, separator); strcat (string, str_array[i]); } } else string = g_strdup (""); return string; } gchar* g_strjoin (const gchar *separator, ...) { gchar *string, *s; va_list args; guint len; guint separator_len; if (separator == NULL) separator = ""; separator_len = strlen (separator); va_start (args, separator); s = va_arg (args, gchar*); if (s) { len = strlen (s); s = va_arg (args, gchar*); while (s) { len += separator_len + strlen (s); s = va_arg (args, gchar*); } va_end (args); string = g_new (gchar, len + 1); *string = 0; va_start (args, separator); s = va_arg (args, gchar*); strcat (string, s); s = va_arg (args, gchar*); while (s) { strcat (string, separator); strcat (string, s); s = va_arg (args, gchar*); } } else string = g_strdup (""); va_end (args); return string; }