1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 /*
25  * Conversion parameters:
26  * inFile  = glib-String-Utility-Functions.html
27  * outPack = glib
28  * outFile = Str
29  * strct   = 
30  * realStrct=
31  * ctorStrct=
32  * clss    = Str
33  * interf  = 
34  * class Code: Yes
35  * interface Code: No
36  * template for:
37  * extend  = 
38  * implements:
39  * prefixes:
40  * 	- g_
41  * omit structs:
42  * omit prefixes:
43  * omit code:
44  * omit signals:
45  * imports:
46  * 	- std.c.stdio
47  * 	- glib.StringG
48  * 	- std.c.string
49  * structWrap:
50  * 	- GString* -> StringG
51  * module aliases:
52  * local aliases:
53  * overrides:
54  */
55 
56 module glib.Str;
57 
58 public  import gtkc.glibtypes;
59 
60 private import gtkc.glib;
61 private import glib.ConstructionException;
62 
63 
64 private import glib.StringG;
65 
66 
67 version(Tango) {
68 	private import tango.stdc.stdio;
69 	private import tango.stdc.string;
70 
71 	version = druntime;
72 } else version(D_Version2) {
73 	private import std.c.stdio;
74 	private import core.stdc.string;
75 
76 	version = druntime;
77 } else {
78 	private import std.c.stdio;
79 	private import std.c.string;
80 }
81 
82 
83 
84 /**
85  * Description
86  * This section describes a number of utility functions for creating,
87  * duplicating, and manipulating strings.
88  * Note that the functions g_printf(), g_fprintf(), g_sprintf(), g_snprintf(),
89  * g_vprintf(), g_vfprintf(), g_vsprintf() and g_vsnprintf() are declared in
90  * the header gprintf.h which is not
91  * included in glib.h (otherwise using
92  * glib.h would drag in stdio.h), so
93  * you'll have to explicitly include <glib/gprintf.h>
94  * in order to use the GLib printf() functions.
95  * While you may use the printf() functions to format UTF-8 strings, notice that
96  * the precision of a %Ns parameter is interpreted as the
97  * number of bytes, not characters to print.
98  * On top of that, the GNU libc implementation of the printf() functions has the "feature"
99  * that it checks that the string given for the %Ns parameter
100  * consists of a whole number of characters in the current encoding. So, unless you
101  * are sure you are always going to be in an UTF-8 locale or your know your text is restricted
102  * to ASCII, avoid using %Ns.
103  * If your intention is to format strings for a certain number of columns, then
104  * %Ns is not a correct solution anyway, since it fails to take
105  * wide characters (see g_unichar_iswide()) into account.
106  */
107 public class Str
108 {
109 	
110 	const static char[10] digits    = "0123456789";			/// 0..9
111 	
112 	/*************************************************
113 	 * Convert C-style 0 terminated string s to char[] string.
114 	 * copied from phobos
115 	 */
116 	public static string toString(char *s, size_t len = 0)
117 	{
118 		if ( s is null )
119 		return cast(string)null;
120 		
121 		if ( len == 0 )
122 		len = strlen(s);
123 		
124 		version(D_Version2)
125 		return s[0 .. len].idup;
126 		else
127 		return s[0 .. len].dup;
128 	}
129 	
130 	/*********************************
131 	 * Convert array of chars s[] to a C-style 0 terminated string.
132 	 * copied from phobos
133 	 */
134 	public static char* toStringz(string s)
135 	in
136 	{
137 	}
138 	out (result)
139 	{
140 		//	if (result)
141 		//	{
142 			//		// TODO this one fails in some case???
143 			//		assert(strlen(result) == s.length);
144 			//		assert(memcmp(result, s, s.length) == 0);
145 		//	}
146 	}
147 	body
148 	{
149 		if ( s is null ) return null;
150 		char[] copy;
151 		
152 		if (s.length == 0)
153 		{
154 			copy = "\0".dup;
155 		}
156 		else
157 		{
158 			// Need to make a copy
159 			copy = new char[s.length + 1];
160 			copy[0..s.length] = s.dup;
161 			copy[s.length] = 0;
162 		}
163 		
164 		return copy.ptr;
165 	}
166 	
167 	/** */
168 	public static char** toStringzArray(string[] args)
169 	{
170 		if ( args is null )
171 		{
172 			return null;
173 		}
174 		char** argv = (new char*[args.length]).ptr;
175 		int argc = 0;
176 		foreach (string p; args)
177 		{
178 			argv[argc++] = cast(char*)(p.dup~'\0');
179 		}
180 		argv[argc] = null;
181 		
182 		return argv;
183 	}
184 	
185 	/** */
186 	public static string[] toStringArray(char** args)
187 	{
188 		if ( args is null )
189 		{
190 			return null;
191 		}
192 		string[] argv;
193 		
194 		char* arg = args[0];
195 		int i=0;
196 		while( (arg) != null && i<10)
197 		{
198 			argv ~= toString(arg);
199 			++i;
200 			arg = args[i];
201 		}
202 		
203 		return argv;
204 	}
205 	
206 	/** */
207 	public static string toString(bool b)
208 	{
209 		return b ? "true" : "false";
210 	}
211 	
212 	/** */
213 	public static char[] toString(char c)
214 	{
215 		char[] result = new char[2];
216 		result[0] = c;
217 		result[1] = 0;
218 		return result[0 .. 1];
219 	}
220 	
221 	/** */
222 	public static string toString(ubyte ub)  { return toString(cast(uint) ub); } /// ditto
223 	/** */
224 	public static string toString(ushort us) { return toString(cast(uint) us); } /// ditto
225 	
226 	/** */
227 	public static string toString(uint u)
228 	{
229 		char[uint.sizeof * 3] buffer = void;
230 		int ndigits;
231 		char c;
232 		string result;
233 		
234 		ndigits = 0;
235 		if (u < 10)
236 		{
237 			version(D_Version2)
238 			result = digits[u .. u + 1].idup;
239 			else
240 			// Avoid storage allocation for simple stuff
241 			result = digits[u .. u + 1];
242 		}
243 		else
244 		{
245 			while (u)
246 			{
247 				c = cast(char)((u % 10) + '0');
248 				u /= 10;
249 				ndigits++;
250 				buffer[buffer.length - ndigits] = c;
251 			}
252 			
253 			version(D_Version2)
254 			{
255 				//result = new char[ndigits];
256 				result = buffer[buffer.length - ndigits .. buffer.length].idup;
257 			}
258 			else
259 			{
260 				result = new char[ndigits];
261 				result[] = buffer[buffer.length - ndigits .. buffer.length];
262 			}
263 		}
264 		return result;
265 	}
266 	
267 	/** */
268 	public static string toString(ulong u)
269 	{
270 		char[ulong.sizeof * 3] buffer;
271 		int ndigits;
272 		char c;
273 		string result;
274 		
275 		if (u < 0x1_0000_0000)
276 		return toString(cast(uint)u);
277 		
278 		ndigits = 0;
279 		while (u)
280 		{
281 			c = cast(char)((u % 10) + '0');
282 			u /= 10;
283 			ndigits++;
284 			buffer[buffer.length - ndigits] = c;
285 		}
286 		
287 		version(D_Version2)
288 		{
289 			//result = new char[ndigits];
290 			result = buffer[buffer.length - ndigits .. buffer.length].idup;
291 		}
292 		else
293 		{
294 			result = new char[ndigits];
295 			result[] = buffer[buffer.length - ndigits .. buffer.length];
296 		}
297 		return result;
298 	}
299 	
300 	/** */
301 	public static string toString(byte b)  { return toString(cast(int) b); } /// ditto
302 	/** */
303 	public static string toString(short s) { return toString(cast(int) s); } /// ditto
304 	
305 	/** */
306 	public static string toString(int i)
307 	{
308 		char[1 + int.sizeof * 3] buffer;
309 		char c;
310 		string result;
311 		
312 		if (i >= 0)
313 		return toString(cast(uint)i);
314 		
315 		uint u = -i;
316 		int ndigits = 1;
317 		while (u)
318 		{
319 			c = cast(char)((u % 10) + '0');
320 			u /= 10;
321 			buffer[buffer.length - ndigits] = c;
322 			ndigits++;
323 		}
324 		buffer[buffer.length - ndigits] = '-';
325 		
326 		version(D_Version2)
327 		{
328 			//result = new char[ndigits];
329 			result = buffer[buffer.length - ndigits .. buffer.length].idup;
330 		}
331 		else
332 		{
333 			result = new char[ndigits];
334 			result[] = buffer[buffer.length - ndigits .. buffer.length];
335 		}
336 		return result;
337 	}
338 	
339 	/**
340 	 */
341 	
342 	/**
343 	 * Duplicates a string. If str is NULL it returns NULL.
344 	 * The returned string should be freed with g_free()
345 	 * when no longer needed.
346 	 * Params:
347 	 * str = the string to duplicate
348 	 * Returns: a newly-allocated copy of str
349 	 */
350 	public static string strdup(string str)
351 	{
352 		// gchar *	 g_strdup (const gchar *str);
353 		return Str.toString(g_strdup(Str.toStringz(str)));
354 	}
355 	
356 	/**
357 	 * Duplicates the first n bytes of a string, returning a newly-allocated
358 	 * buffer n + 1 bytes long which will always be nul-terminated.
359 	 * If str is less than n bytes long the buffer is padded with nuls.
360 	 * If str is NULL it returns NULL.
361 	 * The returned value should be freed when no longer needed.
362 	 * Note
363 	 * To copy a number of characters from a UTF-8 encoded string, use
364 	 * g_utf8_strncpy() instead.
365 	 * Params:
366 	 * str = the string to duplicate
367 	 * n = the maximum number of bytes to copy from str
368 	 * Returns: a newly-allocated buffer containing the first n bytes of str, nul-terminated
369 	 */
370 	public static string strndup(string str, gsize n)
371 	{
372 		// gchar *	 g_strndup (const gchar *str,  gsize n);
373 		return Str.toString(g_strndup(Str.toStringz(str), n));
374 	}
375 	
376 	/**
377 	 * Copies NULL-terminated array of strings. The copy is a deep copy;
378 	 * the new array should be freed by first freeing each string, then
379 	 * the array itself. g_strfreev() does this for you. If called
380 	 * on a NULL value, g_strdupv() simply returns NULL.
381 	 * Params:
382 	 * strArray = NULL-terminated array of strings.
383 	 * Returns: a new NULL-terminated array of strings.
384 	 */
385 	public static string[] strdupv(string[] strArray)
386 	{
387 		// gchar ** g_strdupv (gchar **str_array);
388 		return Str.toStringArray(g_strdupv(Str.toStringzArray(strArray)));
389 	}
390 	
391 	/**
392 	 * Creates a new string length bytes long filled with fill_char.
393 	 * The returned string should be freed when no longer needed.
394 	 * Params:
395 	 * length = the length of the new string
396 	 * fillChar = the byte to fill the string with
397 	 * Returns: a newly-allocated string filled the fill_char
398 	 */
399 	public static string strnfill(gsize length, char fillChar)
400 	{
401 		// gchar *	 g_strnfill (gsize length,  gchar fill_char);
402 		return Str.toString(g_strnfill(length, fillChar));
403 	}
404 	
405 	/**
406 	 * Copies a nul-terminated string into the dest buffer, include the
407 	 * trailing nul, and return a pointer to the trailing nul byte.
408 	 * This is useful for concatenating multiple strings together
409 	 * without having to repeatedly scan for the end.
410 	 * Params:
411 	 * dest = destination buffer.
412 	 * src = source string.
413 	 * Returns: a pointer to trailing nul byte.
414 	 */
415 	public static string stpcpy(string dest, string src)
416 	{
417 		// gchar * g_stpcpy (gchar *dest,  const char *src);
418 		return Str.toString(g_stpcpy(Str.toStringz(dest), Str.toStringz(src)));
419 	}
420 	
421 	/**
422 	 * Searches the string haystack for the first occurrence
423 	 * of the string needle, limiting the length of the search
424 	 * to haystack_len.
425 	 * Params:
426 	 * haystack = a string.
427 	 * haystackLen = the maximum length of haystack. Note that -1 is
428 	 * a valid length, if haystack is nul-terminated, meaning it will
429 	 * search through the whole string.
430 	 * needle = the string to search for.
431 	 * Returns: a pointer to the found occurrence, or NULL if not found.
432 	 */
433 	public static string strstrLen(string haystack, gssize haystackLen, string needle)
434 	{
435 		// gchar * g_strstr_len (const gchar *haystack,  gssize haystack_len,  const gchar *needle);
436 		return Str.toString(g_strstr_len(Str.toStringz(haystack), haystackLen, Str.toStringz(needle)));
437 	}
438 	
439 	/**
440 	 * Searches the string haystack for the last occurrence
441 	 * of the string needle.
442 	 * Params:
443 	 * haystack = a nul-terminated string.
444 	 * needle = the nul-terminated string to search for.
445 	 * Returns: a pointer to the found occurrence, or NULL if not found.
446 	 */
447 	public static string strrstr(string haystack, string needle)
448 	{
449 		// gchar * g_strrstr (const gchar *haystack,  const gchar *needle);
450 		return Str.toString(g_strrstr(Str.toStringz(haystack), Str.toStringz(needle)));
451 	}
452 	
453 	/**
454 	 * Searches the string haystack for the last occurrence
455 	 * of the string needle, limiting the length of the search
456 	 * to haystack_len.
457 	 * Params:
458 	 * haystack = a nul-terminated string.
459 	 * haystackLen = the maximum length of haystack.
460 	 * needle = the nul-terminated string to search for.
461 	 * Returns: a pointer to the found occurrence, or NULL if not found.
462 	 */
463 	public static string strrstrLen(string haystack, gssize haystackLen, string needle)
464 	{
465 		// gchar * g_strrstr_len (const gchar *haystack,  gssize haystack_len,  const gchar *needle);
466 		return Str.toString(g_strrstr_len(Str.toStringz(haystack), haystackLen, Str.toStringz(needle)));
467 	}
468 	
469 	/**
470 	 * Looks whether the string str begins with prefix.
471 	 * Since 2.2
472 	 * Params:
473 	 * str = a nul-terminated string.
474 	 * prefix = the nul-terminated prefix to look for.
475 	 * Returns: TRUE if str begins with prefix, FALSE otherwise.
476 	 */
477 	public static int strHasPrefix(string str, string prefix)
478 	{
479 		// gboolean g_str_has_prefix (const gchar *str,  const gchar *prefix);
480 		return g_str_has_prefix(Str.toStringz(str), Str.toStringz(prefix));
481 	}
482 	
483 	/**
484 	 * Looks whether the string str ends with suffix.
485 	 * Since 2.2
486 	 * Params:
487 	 * str = a nul-terminated string.
488 	 * suffix = the nul-terminated suffix to look for.
489 	 * Returns: TRUE if str end with suffix, FALSE otherwise.
490 	 */
491 	public static int strHasSuffix(string str, string suffix)
492 	{
493 		// gboolean g_str_has_suffix (const gchar *str,  const gchar *suffix);
494 		return g_str_has_suffix(Str.toStringz(str), Str.toStringz(suffix));
495 	}
496 	
497 	/**
498 	 * Compares str1 and str2 like strcmp(). Handles NULL
499 	 * gracefully by sorting it before non-NULL strings.
500 	 * Comparing two NULL pointers returns 0.
501 	 * Since 2.16
502 	 * Params:
503 	 * str1 = a C string or NULL
504 	 * str2 = another C string or NULL
505 	 * Returns: -1, 0 or 1, if str1 is <, == or > than str2.
506 	 */
507 	public static int strcmp0(string str1, string str2)
508 	{
509 		// int g_strcmp0 (const char *str1,  const char *str2);
510 		return g_strcmp0(Str.toStringz(str1), Str.toStringz(str2));
511 	}
512 	
513 	/**
514 	 * Portability wrapper that calls strlcpy() on systems which have it,
515 	 * and emulates strlcpy() otherwise. Copies src to dest; dest is
516 	 * guaranteed to be nul-terminated; src must be nul-terminated;
517 	 * dest_size is the buffer size, not the number of chars to copy.
518 	 * At most dest_size - 1 characters will be copied. Always nul-terminates
519 	 * (unless dest_size == 0). This function does not
520 	 * allocate memory. Unlike strncpy(), this function doesn't pad dest (so
521 	 * it's often faster). It returns the size of the attempted result,
522 	 * strlen (src), so if retval >= dest_size, truncation occurred.
523 	 * Note
524 	 * Caveat: strlcpy() is supposedly more secure than
525 	 * strcpy() or strncpy(), but if you really want to avoid screwups,
526 	 * g_strdup() is an even better idea.
527 	 * Params:
528 	 * dest = destination buffer
529 	 * src = source buffer
530 	 * destSize = length of dest in bytes
531 	 * Returns: length of src
532 	 */
533 	public static gsize strlcpy(string dest, string src, gsize destSize)
534 	{
535 		// gsize g_strlcpy (gchar *dest,  const gchar *src,  gsize dest_size);
536 		return g_strlcpy(Str.toStringz(dest), Str.toStringz(src), destSize);
537 	}
538 	
539 	/**
540 	 * Portability wrapper that calls strlcat() on systems which have it,
541 	 * and emulates it otherwise. Appends nul-terminated src string to dest,
542 	 * guaranteeing nul-termination for dest. The total size of dest won't
543 	 * exceed dest_size.
544 	 * At most dest_size - 1 characters will be copied.
545 	 * Unlike strncat, dest_size is the full size of dest, not the space left over.
546 	 * This function does NOT allocate memory.
547 	 * This always NUL terminates (unless siz == 0 or there were no NUL characters
548 	 * in the dest_size characters of dest to start with).
549 	 * Note
550 	 * Caveat: this is supposedly a more secure alternative to
551 	 * strcat() or strncat(), but for real security g_strconcat() is harder
552 	 * to mess up.
553 	 * Params:
554 	 * dest = destination buffer, already containing one nul-terminated string
555 	 * src = source buffer
556 	 * destSize = length of dest buffer in bytes (not length of existing string
557 	 * inside dest)
558 	 * Returns: size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if retval >= dest_size, truncation occurred.
559 	 */
560 	public static gsize strlcat(string dest, string src, gsize destSize)
561 	{
562 		// gsize g_strlcat (gchar *dest,  const gchar *src,  gsize dest_size);
563 		return g_strlcat(Str.toStringz(dest), Str.toStringz(src), destSize);
564 	}
565 	
566 	/**
567 	 * Similar to the standard C vsprintf() function but safer, since it
568 	 * calculates the maximum space required and allocates memory to hold
569 	 * the result. The returned string should be freed with g_free() when
570 	 * no longer needed.
571 	 * See also g_vasprintf(), which offers the same functionality, but
572 	 * additionally returns the length of the allocated string.
573 	 * Params:
574 	 * format = a standard printf() format string, but notice
575 	 * string precision pitfalls
576 	 * args = the list of parameters to insert into the format string
577 	 * Returns: a newly-allocated string holding the result
578 	 */
579 	public static string strdupVprintf(string format, void* args)
580 	{
581 		// gchar *	 g_strdup_vprintf (const gchar *format,  va_list args);
582 		return Str.toString(g_strdup_vprintf(Str.toStringz(format), args));
583 	}
584 	
585 	/**
586 	 * An implementation of the standard vprintf() function which supports
587 	 * positional parameters, as specified in the Single Unix Specification.
588 	 * Since 2.2
589 	 * Params:
590 	 * format = a standard printf() format string, but notice
591 	 * string precision pitfalls.
592 	 * args = the list of arguments to insert in the output.
593 	 * Returns: the number of bytes printed.
594 	 */
595 	public static int vprintf(string format, void* args)
596 	{
597 		// gint g_vprintf (gchar const *format,  va_list args);
598 		return g_vprintf(Str.toStringz(format), args);
599 	}
600 	
601 	/**
602 	 * An implementation of the standard fprintf() function which supports
603 	 * positional parameters, as specified in the Single Unix Specification.
604 	 * Since 2.2
605 	 * Params:
606 	 * file = the stream to write to.
607 	 * format = a standard printf() format string, but notice
608 	 * string precision pitfalls.
609 	 * args = the list of arguments to insert in the output.
610 	 * Returns: the number of bytes printed.
611 	 */
612 	public static int vfprintf(FILE* file, string format, void* args)
613 	{
614 		// gint g_vfprintf (FILE *file,  gchar const *format,  va_list args);
615 		return g_vfprintf(cast(void*)file, Str.toStringz(format), args);
616 	}
617 	
618 	/**
619 	 * An implementation of the standard vsprintf() function which supports
620 	 * positional parameters, as specified in the Single Unix Specification.
621 	 * Since 2.2
622 	 * Params:
623 	 * string = the buffer to hold the output.
624 	 * format = a standard printf() format string, but notice
625 	 * string precision pitfalls.
626 	 * args = the list of arguments to insert in the output.
627 	 * Returns: the number of bytes printed.
628 	 */
629 	public static int vsprintf(string string, string format, void* args)
630 	{
631 		// gint g_vsprintf (gchar *string,  gchar const *format,  va_list args);
632 		return g_vsprintf(Str.toStringz(string), Str.toStringz(format), args);
633 	}
634 	
635 	/**
636 	 * A safer form of the standard vsprintf() function. The output is guaranteed
637 	 * to not exceed n characters (including the terminating nul character), so
638 	 * it is easy to ensure that a buffer overflow cannot occur.
639 	 * See also g_strdup_vprintf().
640 	 * In versions of GLib prior to 1.2.3, this function may return -1 if the
641 	 * output was truncated, and the truncated string may not be nul-terminated.
642 	 * In versions prior to 1.3.12, this function returns the length of the output
643 	 * string.
644 	 * The return value of g_vsnprintf() conforms to the vsnprintf() function
645 	 * as standardized in ISO C99. Note that this is different from traditional
646 	 * vsnprintf(), which returns the length of the output string.
647 	 * The format string may contain positional parameters, as specified in
648 	 * the Single Unix Specification.
649 	 * Params:
650 	 * string = the buffer to hold the output.
651 	 * n = the maximum number of bytes to produce (including the
652 	 * terminating nul character).
653 	 * format = a standard printf() format string, but notice
654 	 * string precision pitfalls.
655 	 * args = the list of arguments to insert in the output.
656 	 * Returns: the number of bytes which would be produced if the buffer was large enough.
657 	 */
658 	public static int vsnprintf(string string, gulong n, string format, void* args)
659 	{
660 		// gint g_vsnprintf (gchar *string,  gulong n,  gchar const *format,  va_list args);
661 		return g_vsnprintf(Str.toStringz(string), n, Str.toStringz(format), args);
662 	}
663 	
664 	/**
665 	 * An implementation of the GNU vasprintf() function which supports
666 	 * positional parameters, as specified in the Single Unix Specification.
667 	 * This function is similar to g_vsprintf(), except that it allocates a
668 	 * string to hold the output, instead of putting the output in a buffer
669 	 * you allocate in advance.
670 	 * Since 2.4
671 	 * Params:
672 	 * string = the return location for the newly-allocated string.
673 	 * format = a standard printf() format string, but notice
674 	 * string precision pitfalls.
675 	 * args = the list of arguments to insert in the output.
676 	 * Returns: the number of bytes printed.
677 	 */
678 	public static int vasprintf(out string string, string format, void* args)
679 	{
680 		// gint g_vasprintf (gchar **string,  gchar const *format,  va_list args);
681 		char* outstring = null;
682 		
683 		auto p = g_vasprintf(&outstring, Str.toStringz(format), args);
684 		
685 		string = Str.toString(outstring);
686 		return p;
687 	}
688 	
689 	/**
690 	 * Calculates the maximum space needed to store the output of the sprintf()
691 	 * function.
692 	 * Params:
693 	 * format = the format string. See the printf() documentation.
694 	 * args = the parameters to be inserted into the format string.
695 	 * Returns: the maximum space needed to store the formatted string.
696 	 */
697 	public static gsize printfStringUpperBound(string format, void* args)
698 	{
699 		// gsize g_printf_string_upper_bound (const gchar *format,  va_list args);
700 		return g_printf_string_upper_bound(Str.toStringz(format), args);
701 	}
702 	
703 	/**
704 	 * Determines whether a character is alphanumeric.
705 	 * Unlike the standard C library isalnum() function, this only
706 	 * recognizes standard ASCII letters and ignores the locale, returning
707 	 * FALSE for all non-ASCII characters. Also unlike the standard
708 	 * library function, this takes a char, not an int,
709 	 * so don't call it on EOF but no need to cast to guchar before passing a
710 	 * possibly non-ASCII character in.
711 	 * Params:
712 	 * c = any character
713 	 * Returns: TRUE if c is an ASCII alphanumeric character
714 	 */
715 	public static int asciiIsalnum(char c)
716 	{
717 		// gboolean g_ascii_isalnum (gchar c);
718 		return g_ascii_isalnum(c);
719 	}
720 	
721 	/**
722 	 * Determines whether a character is alphabetic (i.e. a letter).
723 	 * Unlike the standard C library isalpha() function, this only
724 	 * recognizes standard ASCII letters and ignores the locale, returning
725 	 * FALSE for all non-ASCII characters. Also unlike the standard
726 	 * library function, this takes a char, not an int,
727 	 * so don't call it on EOF but no need to cast to guchar before passing a
728 	 * possibly non-ASCII character in.
729 	 * Params:
730 	 * c = any character
731 	 * Returns: TRUE if c is an ASCII alphabetic character
732 	 */
733 	public static int asciiIsalpha(char c)
734 	{
735 		// gboolean g_ascii_isalpha (gchar c);
736 		return g_ascii_isalpha(c);
737 	}
738 	
739 	/**
740 	 * Determines whether a character is a control character.
741 	 * Unlike the standard C library iscntrl() function, this only
742 	 * recognizes standard ASCII control characters and ignores the locale,
743 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
744 	 * library function, this takes a char, not an int,
745 	 * so don't call it on EOF but no need to cast to guchar before passing a
746 	 * possibly non-ASCII character in.
747 	 * Params:
748 	 * c = any character
749 	 * Returns: TRUE if c is an ASCII control character.
750 	 */
751 	public static int asciiIscntrl(char c)
752 	{
753 		// gboolean g_ascii_iscntrl (gchar c);
754 		return g_ascii_iscntrl(c);
755 	}
756 	
757 	/**
758 	 * Determines whether a character is digit (0-9).
759 	 * Unlike the standard C library isdigit() function,
760 	 * this takes a char, not an int, so don't call it
761 	 * on EOF but no need to cast to guchar before passing a possibly
762 	 * non-ASCII character in.
763 	 * Params:
764 	 * c = any character
765 	 * Returns: TRUE if c is an ASCII digit.
766 	 */
767 	public static int asciiIsdigit(char c)
768 	{
769 		// gboolean g_ascii_isdigit (gchar c);
770 		return g_ascii_isdigit(c);
771 	}
772 	
773 	/**
774 	 * Determines whether a character is a printing character and not a space.
775 	 * Unlike the standard C library isgraph() function,
776 	 * this only recognizes standard ASCII characters and ignores the locale,
777 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
778 	 * library function, this takes a char, not an int,
779 	 * so don't call it on EOF but no need to cast to guchar before passing a
780 	 * possibly non-ASCII character in.
781 	 * Params:
782 	 * c = any character
783 	 * Returns: TRUE if c is an ASCII printing character other than space.
784 	 */
785 	public static int asciiIsgraph(char c)
786 	{
787 		// gboolean g_ascii_isgraph (gchar c);
788 		return g_ascii_isgraph(c);
789 	}
790 	
791 	/**
792 	 * Determines whether a character is an ASCII lower case letter.
793 	 * Unlike the standard C library islower() function,
794 	 * this only recognizes standard ASCII letters and ignores the locale,
795 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
796 	 * library function, this takes a char, not an int,
797 	 * so don't call it on EOF but no need to worry about casting to guchar
798 	 * before passing a possibly non-ASCII character in.
799 	 * Params:
800 	 * c = any character
801 	 * Returns: TRUE if c is an ASCII lower case letter
802 	 */
803 	public static int asciiIslower(char c)
804 	{
805 		// gboolean g_ascii_islower (gchar c);
806 		return g_ascii_islower(c);
807 	}
808 	
809 	/**
810 	 * Determines whether a character is a printing character.
811 	 * Unlike the standard C library isprint() function,
812 	 * this only recognizes standard ASCII characters and ignores the locale,
813 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
814 	 * library function, this takes a char, not an int,
815 	 * so don't call it on EOF but no need to cast to guchar before passing a
816 	 * possibly non-ASCII character in.
817 	 * Params:
818 	 * c = any character
819 	 * Returns: TRUE if c is an ASCII printing character.
820 	 */
821 	public static int asciiIsprint(char c)
822 	{
823 		// gboolean g_ascii_isprint (gchar c);
824 		return g_ascii_isprint(c);
825 	}
826 	
827 	/**
828 	 * Determines whether a character is a punctuation character.
829 	 * Unlike the standard C library ispunct() function,
830 	 * this only recognizes standard ASCII letters and ignores the locale,
831 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
832 	 * library function, this takes a char, not an int,
833 	 * so don't call it on EOF but no need to cast to guchar before passing a
834 	 * possibly non-ASCII character in.
835 	 * Params:
836 	 * c = any character
837 	 * Returns: TRUE if c is an ASCII punctuation character.
838 	 */
839 	public static int asciiIspunct(char c)
840 	{
841 		// gboolean g_ascii_ispunct (gchar c);
842 		return g_ascii_ispunct(c);
843 	}
844 	
845 	/**
846 	 * Determines whether a character is a white-space character.
847 	 * Unlike the standard C library isspace() function,
848 	 * this only recognizes standard ASCII white-space and ignores the locale,
849 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
850 	 * library function, this takes a char, not an int,
851 	 * so don't call it on EOF but no need to cast to guchar before passing a
852 	 * possibly non-ASCII character in.
853 	 * Params:
854 	 * c = any character
855 	 * Returns: TRUE if c is an ASCII white-space character
856 	 */
857 	public static int asciiIsspace(char c)
858 	{
859 		// gboolean g_ascii_isspace (gchar c);
860 		return g_ascii_isspace(c);
861 	}
862 	
863 	/**
864 	 * Determines whether a character is an ASCII upper case letter.
865 	 * Unlike the standard C library isupper() function,
866 	 * this only recognizes standard ASCII letters and ignores the locale,
867 	 * returning FALSE for all non-ASCII characters. Also unlike the standard
868 	 * library function, this takes a char, not an int,
869 	 * so don't call it on EOF but no need to worry about casting to guchar
870 	 * before passing a possibly non-ASCII character in.
871 	 * Params:
872 	 * c = any character
873 	 * Returns: TRUE if c is an ASCII upper case letter
874 	 */
875 	public static int asciiIsupper(char c)
876 	{
877 		// gboolean g_ascii_isupper (gchar c);
878 		return g_ascii_isupper(c);
879 	}
880 	
881 	/**
882 	 * Determines whether a character is a hexadecimal-digit character.
883 	 * Unlike the standard C library isxdigit() function,
884 	 * this takes a char, not an int, so
885 	 * don't call it on EOF but no need to cast to guchar before passing a
886 	 * possibly non-ASCII character in.
887 	 * Params:
888 	 * c = any character
889 	 * Returns: TRUE if c is an ASCII hexadecimal-digit character.
890 	 */
891 	public static int asciiIsxdigit(char c)
892 	{
893 		// gboolean g_ascii_isxdigit (gchar c);
894 		return g_ascii_isxdigit(c);
895 	}
896 	
897 	/**
898 	 * Determines the numeric value of a character as a decimal
899 	 * digit. Differs from g_unichar_digit_value() because it takes
900 	 * a char, so there's no worry about sign extension if characters
901 	 * are signed.
902 	 * Params:
903 	 * c = an ASCII character.
904 	 * Returns: If c is a decimal digit (according to g_ascii_isdigit()), its numeric value. Otherwise, -1.
905 	 */
906 	public static int asciiDigitValue(char c)
907 	{
908 		// gint g_ascii_digit_value (gchar c);
909 		return g_ascii_digit_value(c);
910 	}
911 	
912 	/**
913 	 * Determines the numeric value of a character as a hexidecimal
914 	 * digit. Differs from g_unichar_xdigit_value() because it takes
915 	 * a char, so there's no worry about sign extension if characters
916 	 * are signed.
917 	 * Params:
918 	 * c = an ASCII character.
919 	 * Returns: If c is a hex digit (according to g_ascii_isxdigit()), its numeric value. Otherwise, -1.
920 	 */
921 	public static int asciiXdigitValue(char c)
922 	{
923 		// gint g_ascii_xdigit_value (gchar c);
924 		return g_ascii_xdigit_value(c);
925 	}
926 	
927 	/**
928 	 * Compare two strings, ignoring the case of ASCII characters.
929 	 * Unlike the BSD strcasecmp() function, this only recognizes standard
930 	 * ASCII letters and ignores the locale, treating all non-ASCII
931 	 * bytes as if they are not letters.
932 	 * This function should be used only on strings that are known to be
933 	 * in encodings where the bytes corresponding to ASCII letters always
934 	 * represent themselves. This includes UTF-8 and the ISO-8859-*
935 	 * charsets, but not for instance double-byte encodings like the
936 	 * Windows Codepage 932, where the trailing bytes of double-byte
937 	 * characters include all ASCII letters. If you compare two CP932
938 	 * strings using this function, you will get false matches.
939 	 * Params:
940 	 * s1 = string to compare with s2.
941 	 * s2 = string to compare with s1.
942 	 * Returns: 0 if the strings match, a negative value if s1 < s2, or a positive value if s1 > s2.
943 	 */
944 	public static int asciiStrcasecmp(string s1, string s2)
945 	{
946 		// gint g_ascii_strcasecmp (const gchar *s1,  const gchar *s2);
947 		return g_ascii_strcasecmp(Str.toStringz(s1), Str.toStringz(s2));
948 	}
949 	
950 	/**
951 	 * Compare s1 and s2, ignoring the case of ASCII characters and any
952 	 * characters after the first n in each string.
953 	 * Unlike the BSD strcasecmp() function, this only recognizes standard
954 	 * ASCII letters and ignores the locale, treating all non-ASCII
955 	 * characters as if they are not letters.
956 	 * The same warning as in g_ascii_strcasecmp() applies: Use this
957 	 * function only on strings known to be in encodings where bytes
958 	 * corresponding to ASCII letters always represent themselves.
959 	 * Params:
960 	 * s1 = string to compare with s2.
961 	 * s2 = string to compare with s1.
962 	 * n = number of characters to compare.
963 	 * Returns: 0 if the strings match, a negative value if s1 < s2, or a positive value if s1 > s2.
964 	 */
965 	public static int asciiStrncasecmp(string s1, string s2, gsize n)
966 	{
967 		// gint g_ascii_strncasecmp (const gchar *s1,  const gchar *s2,  gsize n);
968 		return g_ascii_strncasecmp(Str.toStringz(s1), Str.toStringz(s2), n);
969 	}
970 	
971 	/**
972 	 * Converts all lower case ASCII letters to upper case ASCII letters.
973 	 * Params:
974 	 * str = a string.
975 	 * len = length of str in bytes, or -1 if str is nul-terminated.
976 	 * Returns: a newly allocated string, with all the lower case characters in str converted to upper case, with semantics that exactly match g_ascii_toupper(). (Note that this is unlike the old g_strup(), which modified the string in place.)
977 	 */
978 	public static string asciiStrup(string str, gssize len)
979 	{
980 		// gchar * g_ascii_strup (const gchar *str,  gssize len);
981 		return Str.toString(g_ascii_strup(Str.toStringz(str), len));
982 	}
983 	
984 	/**
985 	 * Converts all upper case ASCII letters to lower case ASCII letters.
986 	 * Params:
987 	 * str = a string.
988 	 * len = length of str in bytes, or -1 if str is nul-terminated.
989 	 * Returns: a newly-allocated string, with all the upper case characters in str converted to lower case, with semantics that exactly match g_ascii_tolower(). (Note that this is unlike the old g_strdown(), which modified the string in place.)
990 	 */
991 	public static string asciiStrdown(string str, gssize len)
992 	{
993 		// gchar * g_ascii_strdown (const gchar *str,  gssize len);
994 		return Str.toString(g_ascii_strdown(Str.toStringz(str), len));
995 	}
996 	
997 	/**
998 	 * Convert a character to ASCII lower case.
999 	 * Unlike the standard C library tolower() function, this only
1000 	 * recognizes standard ASCII letters and ignores the locale, returning
1001 	 * all non-ASCII characters unchanged, even if they are lower case
1002 	 * letters in a particular character set. Also unlike the standard
1003 	 * library function, this takes and returns a char, not an int, so
1004 	 * don't call it on EOF but no need to worry about casting to guchar
1005 	 * before passing a possibly non-ASCII character in.
1006 	 * Params:
1007 	 * c = any character.
1008 	 * Returns: the result of converting c to lower case. If c is not an ASCII upper case letter, c is returned unchanged.
1009 	 */
1010 	public static char asciiTolower(char c)
1011 	{
1012 		// gchar g_ascii_tolower (gchar c);
1013 		return g_ascii_tolower(c);
1014 	}
1015 	
1016 	/**
1017 	 * Convert a character to ASCII upper case.
1018 	 * Unlike the standard C library toupper() function, this only
1019 	 * recognizes standard ASCII letters and ignores the locale, returning
1020 	 * all non-ASCII characters unchanged, even if they are upper case
1021 	 * letters in a particular character set. Also unlike the standard
1022 	 * library function, this takes and returns a char, not an int, so
1023 	 * don't call it on EOF but no need to worry about casting to guchar
1024 	 * before passing a possibly non-ASCII character in.
1025 	 * Params:
1026 	 * c = any character.
1027 	 * Returns: the result of converting c to upper case. If c is not an ASCII lower case letter, c is returned unchanged.
1028 	 */
1029 	public static char asciiToupper(char c)
1030 	{
1031 		// gchar g_ascii_toupper (gchar c);
1032 		return g_ascii_toupper(c);
1033 	}
1034 	
1035 	/**
1036 	 * Converts all lower case ASCII letters to upper case ASCII letters.
1037 	 * Params:
1038 	 * string = a GString
1039 	 * Returns: passed-in string pointer, with all the lower case characters converted to upper case in place, with semantics that exactly match g_ascii_toupper().
1040 	 */
1041 	public static StringG stringAsciiUp(StringG string)
1042 	{
1043 		// GString * g_string_ascii_up (GString *string);
1044 		auto p = g_string_ascii_up((string is null) ? null : string.getStringGStruct());
1045 		
1046 		if(p is null)
1047 		{
1048 			return null;
1049 		}
1050 		
1051 		return new StringG(cast(GString*) p);
1052 	}
1053 	
1054 	/**
1055 	 * Converts all upper case ASCII letters to lower case ASCII letters.
1056 	 * Params:
1057 	 * string = a GString
1058 	 * Returns: passed-in string pointer, with all the upper case characters converted to lower case in place, with semantics that exactly match g_ascii_tolower().
1059 	 */
1060 	public static StringG stringAsciiDown(StringG string)
1061 	{
1062 		// GString * g_string_ascii_down (GString *string);
1063 		auto p = g_string_ascii_down((string is null) ? null : string.getStringGStruct());
1064 		
1065 		if(p is null)
1066 		{
1067 			return null;
1068 		}
1069 		
1070 		return new StringG(cast(GString*) p);
1071 	}
1072 	
1073 	/**
1074 	 * Warning
1075 	 * g_strup has been deprecated since version 2.2 and should not be used in newly-written code. This function is totally broken for the reasons discussed
1076 	 * in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
1077 	 * Converts a string to upper case.
1078 	 * Params:
1079 	 * string = the string to convert.
1080 	 * Returns: the string
1081 	 */
1082 	public static string strup(string string)
1083 	{
1084 		// gchar *	 g_strup (gchar *string);
1085 		return Str.toString(g_strup(Str.toStringz(string)));
1086 	}
1087 	
1088 	/**
1089 	 * Warning
1090 	 * g_strdown has been deprecated since version 2.2 and should not be used in newly-written code. This function is totally broken for the reasons discussed
1091 	 * in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
1092 	 * instead.
1093 	 * Converts a string to lower case.
1094 	 * Params:
1095 	 * string = the string to convert.
1096 	 * Returns: the string
1097 	 */
1098 	public static string strdown(string string)
1099 	{
1100 		// gchar *	 g_strdown (gchar *string);
1101 		return Str.toString(g_strdown(Str.toStringz(string)));
1102 	}
1103 	
1104 	/**
1105 	 * Warning
1106 	 * g_strcasecmp has been deprecated since version 2.2 and should not be used in newly-written code. See g_strncasecmp() for a discussion of why this function
1107 	 *  is deprecated and how to replace it.
1108 	 * A case-insensitive string comparison, corresponding to the standard
1109 	 * strcasecmp() function on platforms which support it.
1110 	 * Params:
1111 	 * s1 = a string.
1112 	 * s2 = a string to compare with s1.
1113 	 * Returns: 0 if the strings match, a negative value if s1 < s2, or a positive value if s1 > s2.
1114 	 */
1115 	public static int strcasecmp(string s1, string s2)
1116 	{
1117 		// gint g_strcasecmp (const gchar *s1,  const gchar *s2);
1118 		return g_strcasecmp(Str.toStringz(s1), Str.toStringz(s2));
1119 	}
1120 	
1121 	/**
1122 	 * Warning
1123 	 * g_strncasecmp has been deprecated since version 2.2 and should not be used in newly-written code. The problem with g_strncasecmp() is that it does the
1124 	 * comparison by calling toupper()/tolower(). These functions are
1125 	 * locale-specific and operate on single bytes. However, it is impossible
1126 	 * to handle things correctly from an I18N standpoint by operating on
1127 	 * bytes, since characters may be multibyte. Thus g_strncasecmp() is
1128 	 * broken if your string is guaranteed to be ASCII, since it's
1129 	 * locale-sensitive, and it's broken if your string is localized, since
1130 	 * it doesn't work on many encodings at all, including UTF-8, EUC-JP,
1131 	 * etc.
1132 	 * There are therefore two replacement functions: g_ascii_strncasecmp(),
1133 	 * which only works on ASCII and is not locale-sensitive, and
1134 	 * g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.
1135 	 * A case-insensitive string comparison, corresponding to the standard
1136 	 * strncasecmp() function on platforms which support it.
1137 	 * It is similar to g_strcasecmp() except it only compares the first n
1138 	 * characters of the strings.
1139 	 * Params:
1140 	 * s1 = a string.
1141 	 * s2 = a string to compare with s1.
1142 	 * n = the maximum number of characters to compare.
1143 	 * Returns: 0 if the strings match, a negative value if s1 < s2, or a positive value if s1 > s2.
1144 	 */
1145 	public static int strncasecmp(string s1, string s2, uint n)
1146 	{
1147 		// gint g_strncasecmp (const gchar *s1,  const gchar *s2,  guint n);
1148 		return g_strncasecmp(Str.toStringz(s1), Str.toStringz(s2), n);
1149 	}
1150 	
1151 	/**
1152 	 * Reverses all of the bytes in a string. For example,
1153 	 * g_strreverse ("abcdef") will result
1154 	 * in "fedcba".
1155 	 * Note that g_strreverse() doesn't work on UTF-8 strings
1156 	 * containing multibyte characters. For that purpose, use
1157 	 * g_utf8_strreverse().
1158 	 * Params:
1159 	 * string = the string to reverse
1160 	 * Returns: the same pointer passed in as string
1161 	 */
1162 	public static string strreverse(string string)
1163 	{
1164 		// gchar *	 g_strreverse (gchar *string);
1165 		return Str.toString(g_strreverse(Str.toStringz(string)));
1166 	}
1167 	
1168 	/**
1169 	 * Converts a string to a gint64 value.
1170 	 * This function behaves like the standard strtoll() function
1171 	 * does in the C locale. It does this without actually
1172 	 * changing the current locale, since that would not be
1173 	 * thread-safe.
1174 	 * This function is typically used when reading configuration
1175 	 * files or other non-user input that should be locale independent.
1176 	 * To handle input from the user you should normally use the
1177 	 * locale-sensitive system strtoll() function.
1178 	 * If the correct value would cause overflow, G_MAXINT64 or G_MININT64
1179 	 * is returned, and ERANGE is stored in errno. If the base is
1180 	 * outside the valid range, zero is returned, and EINVAL is stored
1181 	 * in errno. If the string conversion fails, zero is returned, and
1182 	 * endptr returns nptr (if endptr is non-NULL).
1183 	 * Since 2.12
1184 	 * Params:
1185 	 * nptr = the string to convert to a numeric value.
1186 	 * endptr = if non-NULL, it returns the character after
1187 	 * the last character used in the conversion.
1188 	 * base = to be used for the conversion, 2..36 or 0
1189 	 * Returns: the gint64 value or zero on error.
1190 	 */
1191 	public static long asciiStrtoll(string nptr, out string endptr, uint base)
1192 	{
1193 		// gint64 g_ascii_strtoll (const gchar *nptr,  gchar **endptr,  guint base);
1194 		char* outendptr = null;
1195 		
1196 		auto p = g_ascii_strtoll(Str.toStringz(nptr), &outendptr, base);
1197 		
1198 		endptr = Str.toString(outendptr);
1199 		return p;
1200 	}
1201 	
1202 	/**
1203 	 * Converts a string to a guint64 value.
1204 	 * This function behaves like the standard strtoull() function
1205 	 * does in the C locale. It does this without actually
1206 	 * changing the current locale, since that would not be
1207 	 * thread-safe.
1208 	 * This function is typically used when reading configuration
1209 	 * files or other non-user input that should be locale independent.
1210 	 * To handle input from the user you should normally use the
1211 	 * locale-sensitive system strtoull() function.
1212 	 * If the correct value would cause overflow, G_MAXUINT64
1213 	 * is returned, and ERANGE is stored in errno. If the base is
1214 	 * outside the valid range, zero is returned, and EINVAL is stored
1215 	 * in errno. If the string conversion fails, zero is returned, and
1216 	 * endptr returns nptr (if endptr is non-NULL).
1217 	 * Since 2.2
1218 	 * Params:
1219 	 * nptr = the string to convert to a numeric value.
1220 	 * endptr = if non-NULL, it returns the character after
1221 	 * the last character used in the conversion.
1222 	 * base = to be used for the conversion, 2..36 or 0
1223 	 * Returns: the guint64 value or zero on error.
1224 	 */
1225 	public static ulong asciiStrtoull(string nptr, out string endptr, uint base)
1226 	{
1227 		// guint64 g_ascii_strtoull (const gchar *nptr,  gchar **endptr,  guint base);
1228 		char* outendptr = null;
1229 		
1230 		auto p = g_ascii_strtoull(Str.toStringz(nptr), &outendptr, base);
1231 		
1232 		endptr = Str.toString(outendptr);
1233 		return p;
1234 	}
1235 	
1236 	/**
1237 	 * Converts a string to a gdouble value.
1238 	 * This function behaves like the standard strtod() function
1239 	 * does in the C locale. It does this without actually changing
1240 	 * the current locale, since that would not be thread-safe.
1241 	 * A limitation of the implementation is that this function
1242 	 * will still accept localized versions of infinities and NANs.
1243 	 * This function is typically used when reading configuration
1244 	 * files or other non-user input that should be locale independent.
1245 	 * To handle input from the user you should normally use the
1246 	 * locale-sensitive system strtod() function.
1247 	 * To convert from a gdouble to a string in a locale-insensitive
1248 	 * way, use g_ascii_dtostr().
1249 	 * If the correct value would cause overflow, plus or minus HUGE_VAL
1250 	 * is returned (according to the sign of the value), and ERANGE is
1251 	 * stored in errno. If the correct value would cause underflow,
1252 	 * zero is returned and ERANGE is stored in errno.
1253 	 * This function resets errno before calling strtod() so that
1254 	 * you can reliably detect overflow and underflow.
1255 	 * Params:
1256 	 * nptr = the string to convert to a numeric value.
1257 	 * endptr = if non-NULL, it returns the character after
1258 	 * the last character used in the conversion.
1259 	 * Returns: the gdouble value.
1260 	 */
1261 	public static double asciiStrtod(string nptr, out string endptr)
1262 	{
1263 		// gdouble g_ascii_strtod (const gchar *nptr,  gchar **endptr);
1264 		char* outendptr = null;
1265 		
1266 		auto p = g_ascii_strtod(Str.toStringz(nptr), &outendptr);
1267 		
1268 		endptr = Str.toString(outendptr);
1269 		return p;
1270 	}
1271 	
1272 	/**
1273 	 * Converts a gdouble to a string, using the '.' as
1274 	 * decimal point.
1275 	 * This functions generates enough precision that converting
1276 	 * the string back using g_ascii_strtod() gives the same machine-number
1277 	 * (on machines with IEEE compatible 64bit doubles). It is
1278 	 * guaranteed that the size of the resulting string will never
1279 	 * be larger than G_ASCII_DTOSTR_BUF_SIZE bytes.
1280 	 * Params:
1281 	 * buffer = A buffer to place the resulting string in
1282 	 * bufLen = The length of the buffer.
1283 	 * d = The gdouble to convert
1284 	 * Returns: The pointer to the buffer with the converted string.
1285 	 */
1286 	public static string asciiDtostr(string buffer, int bufLen, double d)
1287 	{
1288 		// gchar * g_ascii_dtostr (gchar *buffer,  gint buf_len,  gdouble d);
1289 		return Str.toString(g_ascii_dtostr(Str.toStringz(buffer), bufLen, d));
1290 	}
1291 	
1292 	/**
1293 	 * Converts a gdouble to a string, using the '.' as
1294 	 * decimal point. To format the number you pass in
1295 	 * a printf()-style format string. Allowed conversion
1296 	 * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
1297 	 * If you just want to want to serialize the value into a
1298 	 * string, use g_ascii_dtostr().
1299 	 * Params:
1300 	 * buffer = A buffer to place the resulting string in
1301 	 * bufLen = The length of the buffer.
1302 	 * format = The printf()-style format to use for the
1303 	 * code to use for converting.
1304 	 * d = The gdouble to convert
1305 	 * Returns: The pointer to the buffer with the converted string.
1306 	 */
1307 	public static string asciiFormatd(string buffer, int bufLen, string format, double d)
1308 	{
1309 		// gchar * g_ascii_formatd (gchar *buffer,  gint buf_len,  const gchar *format,  gdouble d);
1310 		return Str.toString(g_ascii_formatd(Str.toStringz(buffer), bufLen, Str.toStringz(format), d));
1311 	}
1312 	
1313 	/**
1314 	 * Converts a string to a gdouble value.
1315 	 * It calls the standard strtod() function to handle the conversion, but
1316 	 * if the string is not completely converted it attempts the conversion
1317 	 * again with g_ascii_strtod(), and returns the best match.
1318 	 * This function should seldomly be used. The normal situation when reading
1319 	 * numbers not for human consumption is to use g_ascii_strtod(). Only when
1320 	 * you know that you must expect both locale formatted and C formatted numbers
1321 	 * should you use this. Make sure that you don't pass strings such as comma
1322 	 * separated lists of values, since the commas may be interpreted as a decimal
1323 	 * point in some locales, causing unexpected results.
1324 	 * Params:
1325 	 * nptr = the string to convert to a numeric value.
1326 	 * endptr = if non-NULL, it returns the character after
1327 	 * the last character used in the conversion.
1328 	 * Returns: the gdouble value.
1329 	 */
1330 	public static double strtod(string nptr, out string endptr)
1331 	{
1332 		// gdouble g_strtod (const gchar *nptr,  gchar **endptr);
1333 		char* outendptr = null;
1334 		
1335 		auto p = g_strtod(Str.toStringz(nptr), &outendptr);
1336 		
1337 		endptr = Str.toString(outendptr);
1338 		return p;
1339 	}
1340 	
1341 	/**
1342 	 * Removes leading whitespace from a string, by moving the rest of the
1343 	 * characters forward.
1344 	 * This function doesn't allocate or reallocate any memory; it modifies string
1345 	 * in place. The pointer to string is returned to allow the nesting of functions.
1346 	 * Also see g_strchomp() and g_strstrip().
1347 	 * Params:
1348 	 * string = a string to remove the leading whitespace from.
1349 	 * Returns: string.
1350 	 */
1351 	public static string strchug(string string)
1352 	{
1353 		// gchar * g_strchug (gchar *string);
1354 		return Str.toString(g_strchug(Str.toStringz(string)));
1355 	}
1356 	
1357 	/**
1358 	 * Removes trailing whitespace from a string.
1359 	 * This function doesn't allocate or reallocate any memory; it modifies string in
1360 	 * place. The pointer to string is returned to allow the nesting of functions.
1361 	 * Also see g_strchug() and g_strstrip().
1362 	 * Params:
1363 	 * string = a string to remove the trailing whitespace from.
1364 	 * Returns: string.
1365 	 */
1366 	public static string strchomp(string string)
1367 	{
1368 		// gchar * g_strchomp (gchar *string);
1369 		return Str.toString(g_strchomp(Str.toStringz(string)));
1370 	}
1371 	
1372 	/**
1373 	 * Converts any delimiter characters in string to new_delimiter.
1374 	 * Any characters in string which are found in delimiters are changed
1375 	 * to the new_delimiter character. Modifies string in place, and returns
1376 	 * string itself, not a copy. The return value is to allow nesting such as
1377 	 * g_ascii_strup (g_strdelimit (str, "abc", '?')).
1378 	 * Params:
1379 	 * string = the string to convert.
1380 	 * delimiters = a string containing the current delimiters, or NULL to use the
1381 	 * standard delimiters defined in G_STR_DELIMITERS.
1382 	 * newDelimiter = the new delimiter character.
1383 	 * Returns: string.
1384 	 */
1385 	public static string strdelimit(string string, string delimiters, char newDelimiter)
1386 	{
1387 		// gchar *	 g_strdelimit (gchar *string,  const gchar *delimiters,  gchar new_delimiter);
1388 		return Str.toString(g_strdelimit(Str.toStringz(string), Str.toStringz(delimiters), newDelimiter));
1389 	}
1390 	
1391 	/**
1392 	 * Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\' and
1393 	 * '"' in the string source by inserting a '\' before
1394 	 * them. Additionally all characters in the range 0x01-0x1F (everything
1395 	 * below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are
1396 	 * replaced with a '\' followed by their octal representation. Characters
1397 	 * supplied in exceptions are not escaped.
1398 	 * g_strcompress() does the reverse conversion.
1399 	 * Params:
1400 	 * source = a string to escape.
1401 	 * exceptions = a string of characters not to escape in source.
1402 	 * Returns: a newly-allocated copy of source with certain characters escaped. See above.
1403 	 */
1404 	public static string strescape(string source, string exceptions)
1405 	{
1406 		// gchar * g_strescape (const gchar *source,  const gchar *exceptions);
1407 		return Str.toString(g_strescape(Str.toStringz(source), Str.toStringz(exceptions)));
1408 	}
1409 	
1410 	/**
1411 	 * Replaces all escaped characters with their one byte equivalent. It
1412 	 * does the reverse conversion of g_strescape().
1413 	 * Params:
1414 	 * source = a string to compress.
1415 	 * Returns: a newly-allocated copy of source with all escaped character compressed.
1416 	 */
1417 	public static string strcompress(string source)
1418 	{
1419 		// gchar * g_strcompress (const gchar *source);
1420 		return Str.toString(g_strcompress(Str.toStringz(source)));
1421 	}
1422 	
1423 	/**
1424 	 * For each character in string, if the character is not in valid_chars,
1425 	 * replaces the character with substitutor. Modifies string in place,
1426 	 * and return string itself, not a copy. The return value is to allow
1427 	 * nesting such as g_ascii_strup (g_strcanon (str, "abc", '?')).
1428 	 * Params:
1429 	 * string = a nul-terminated array of bytes.
1430 	 * validChars = bytes permitted in string.
1431 	 * substitutor = replacement character for disallowed bytes.
1432 	 * Returns: string.
1433 	 */
1434 	public static string strcanon(string string, string validChars, char substitutor)
1435 	{
1436 		// gchar *	 g_strcanon (gchar *string,  const gchar *valid_chars,  gchar substitutor);
1437 		return Str.toString(g_strcanon(Str.toStringz(string), Str.toStringz(validChars), substitutor));
1438 	}
1439 	
1440 	/**
1441 	 * Splits a string into a maximum of max_tokens pieces, using the given
1442 	 * delimiter. If max_tokens is reached, the remainder of string is appended
1443 	 * to the last token.
1444 	 * As a special case, the result of splitting the empty string "" is an empty
1445 	 * vector, not a vector containing a single string. The reason for this
1446 	 * special case is that being able to represent a empty vector is typically
1447 	 * more useful than consistent handling of empty elements. If you do need
1448 	 * to represent empty elements, you'll need to check for the empty string
1449 	 * before calling g_strsplit().
1450 	 * Params:
1451 	 * string = a string to split.
1452 	 * delimiter = a string which specifies the places at which to split the string.
1453 	 * The delimiter is not included in any of the resulting strings, unless
1454 	 * max_tokens is reached.
1455 	 * maxTokens = the maximum number of pieces to split string into. If this is
1456 	 * less than 1, the string is split completely.
1457 	 * Returns: a newly-allocated NULL-terminated array of strings. Use g_strfreev() to free it.
1458 	 */
1459 	public static string[] strsplit(string string, string delimiter, int maxTokens)
1460 	{
1461 		// gchar **	 g_strsplit (const gchar *string,  const gchar *delimiter,  gint max_tokens);
1462 		return Str.toStringArray(g_strsplit(Str.toStringz(string), Str.toStringz(delimiter), maxTokens));
1463 	}
1464 	
1465 	/**
1466 	 * Splits string into a number of tokens not containing any of the characters
1467 	 * in delimiter. A token is the (possibly empty) longest string that does not
1468 	 * contain any of the characters in delimiters. If max_tokens is reached, the
1469 	 * remainder is appended to the last token.
1470 	 * For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a
1471 	 * NULL-terminated vector containing the three strings "abc", "def",
1472 	 * and "ghi".
1473 	 * The result if g_strsplit_set (":def/ghi:", ":/", -1) is a NULL-terminated
1474 	 * vector containing the four strings "", "def", "ghi", and "".
1475 	 * As a special case, the result of splitting the empty string "" is an empty
1476 	 * vector, not a vector containing a single string. The reason for this
1477 	 * special case is that being able to represent a empty vector is typically
1478 	 * more useful than consistent handling of empty elements. If you do need
1479 	 * to represent empty elements, you'll need to check for the empty string
1480 	 * before calling g_strsplit_set().
1481 	 * Note that this function works on bytes not characters, so it can't be used
1482 	 * to delimit UTF-8 strings for anything but ASCII characters.
1483 	 * Since 2.4
1484 	 * Params:
1485 	 * string = The string to be tokenized
1486 	 * delimiters = A nul-terminated string containing bytes that are used
1487 	 * to split the string.
1488 	 * maxTokens = The maximum number of tokens to split string into.
1489 	 * If this is less than 1, the string is split completely
1490 	 * Returns: a newly-allocated NULL-terminated array of strings. Use g_strfreev() to free it.
1491 	 */
1492 	public static string[] strsplitSet(string string, string delimiters, int maxTokens)
1493 	{
1494 		// gchar **	 g_strsplit_set (const gchar *string,  const gchar *delimiters,  gint max_tokens);
1495 		return Str.toStringArray(g_strsplit_set(Str.toStringz(string), Str.toStringz(delimiters), maxTokens));
1496 	}
1497 	
1498 	/**
1499 	 * Frees a NULL-terminated array of strings, and the array itself.
1500 	 * If called on a NULL value, g_strfreev() simply returns.
1501 	 * Params:
1502 	 * strArray = a NULL-terminated array of strings to free.
1503 	 */
1504 	public static void strfreev(string[] strArray)
1505 	{
1506 		// void g_strfreev (gchar **str_array);
1507 		g_strfreev(Str.toStringzArray(strArray));
1508 	}
1509 	
1510 	/**
1511 	 * Joins a number of strings together to form one long string, with the
1512 	 * optional separator inserted between each of them. The returned string
1513 	 * should be freed with g_free().
1514 	 * Params:
1515 	 * separator = a string to insert between each of the strings, or NULL
1516 	 * strArray = a NULL-terminated array of strings to join
1517 	 * Returns: a newly-allocated string containing all of the strings joined together, with separator between them
1518 	 */
1519 	public static string strjoinv(string separator, string[] strArray)
1520 	{
1521 		// gchar * g_strjoinv (const gchar *separator,  gchar **str_array);
1522 		return Str.toString(g_strjoinv(Str.toStringz(separator), Str.toStringzArray(strArray)));
1523 	}
1524 	
1525 	/**
1526 	 * Returns the length of the given NULL-terminated
1527 	 * string array str_array.
1528 	 * Since 2.6
1529 	 * Params:
1530 	 * strArray = a NULL-terminated array of strings.
1531 	 * Returns: length of str_array.
1532 	 */
1533 	public static uint strvLength(string[] strArray)
1534 	{
1535 		// guint g_strv_length (gchar **str_array);
1536 		return g_strv_length(Str.toStringzArray(strArray));
1537 	}
1538 	
1539 	/**
1540 	 * Returns a string corresponding to the given error code, e.g.
1541 	 * "no such process". You should use this function in preference to
1542 	 * strerror(), because it returns a string in UTF-8 encoding, and since
1543 	 * not all platforms support the strerror() function.
1544 	 * Params:
1545 	 * errnum = the system error number. See the standard C errno
1546 	 * documentation
1547 	 * Returns: a UTF-8 string describing the error code. If the error code is unknown, it returns "unknown error (<code>)". The string can only be used until the next call to g_strerror()
1548 	 */
1549 	public static string strerror(int errnum)
1550 	{
1551 		// const gchar * g_strerror (gint errnum);
1552 		return Str.toString(g_strerror(errnum));
1553 	}
1554 	
1555 	/**
1556 	 * Returns a string describing the given signal, e.g. "Segmentation fault".
1557 	 * You should use this function in preference to strsignal(), because it
1558 	 * returns a string in UTF-8 encoding, and since not all platforms support
1559 	 * the strsignal() function.
1560 	 * Params:
1561 	 * signum = the signal number. See the signal
1562 	 * documentation
1563 	 * Returns: a UTF-8 string describing the signal. If the signal is unknown, it returns "unknown signal (<signum>)". The string can only be used until the next call to g_strsignal()
1564 	 */
1565 	public static string strsignal(int signum)
1566 	{
1567 		// const gchar * g_strsignal (gint signum);
1568 		return Str.toString(g_strsignal(signum));
1569 	}
1570 }