version 4.0 release

17 files changed, 5087 insertions, 0 deletions

diff --git a/ConvertUTF.c b/ConvertUTF.c
new file mode 100644
index 0000000..9b3deeb
--- /dev/null
+++ b/ConvertUTF.c
@@ -0,0 +1,539 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+    Sept 2001: fixed const & error conditions per
+	mods suggested by S. Parent & A. Lillich.
+    June 2002: Tim Dodd added detection and handling of incomplete
+	source sequences, enhanced error detection, added casts
+	to eliminate compiler warnings.
+    July 2003: slight mods to back out aggressive FFFE detection.
+    Jan 2004: updated switches in from-UTF8 conversions.
+    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
+
+    See the header file "ConvertUTF.h" for complete documentation.
+
+------------------------------------------------------------------------ */
+
+
+#include "ConvertUTF.h"
+#ifdef CVTUTF_DEBUG
+#include <stdio.h>
+#endif
+
+static const int halfShift  = 10; /* used for shifting by 10 bits */
+
+static const UTF32 halfBase = 0x0010000UL;
+static const UTF32 halfMask = 0x3FFUL;
+
+#define UNI_SUR_HIGH_START  (UTF32)0xD800
+#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
+#define UNI_SUR_LOW_START   (UTF32)0xDC00
+#define UNI_SUR_LOW_END     (UTF32)0xDFFF
+#define false	   0
+#define true	    1
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF32toUTF16 (
+	const UTF32** sourceStart, const UTF32* sourceEnd, 
+	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF32* source = *sourceStart;
+    UTF16* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	if (target >= targetEnd) {
+	    result = targetExhausted; break;
+	}
+	ch = *source++;
+	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+	    /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = (UTF16)ch; /* normal case */
+	    }
+	} else if (ch > UNI_MAX_LEGAL_UTF32) {
+	    if (flags == strictConversion) {
+		result = sourceIllegal;
+	    } else {
+		*target++ = UNI_REPLACEMENT_CHAR;
+	    }
+	} else {
+	    /* target is a character in range 0xFFFF - 0x10FFFF. */
+	    if (target + 1 >= targetEnd) {
+		--source; /* Back up source pointer! */
+		result = targetExhausted; break;
+	    }
+	    ch -= halfBase;
+	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
+	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF16toUTF32 (
+	const UTF16** sourceStart, const UTF16* sourceEnd, 
+	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF16* source = *sourceStart;
+    UTF32* target = *targetStart;
+    UTF32 ch, ch2;
+    while (source < sourceEnd) {
+	const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
+	ch = *source++;
+	/* If we have a surrogate pair, convert to UTF32 first. */
+	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+	    /* If the 16 bits following the high surrogate are in the source buffer... */
+	    if (source < sourceEnd) {
+		ch2 = *source;
+		/* If it's a low surrogate, convert to UTF32. */
+		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
+		    ++source;
+		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		}
+	    } else { /* We don't have the 16 bits following the high surrogate. */
+		--source; /* return to the high surrogate */
+		result = sourceExhausted;
+		break;
+	    }
+	} else if (flags == strictConversion) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	if (target >= targetEnd) {
+	    source = oldSource; /* Back up source pointer! */
+	    result = targetExhausted; break;
+	}
+	*target++ = ch;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+#ifdef CVTUTF_DEBUG
+if (result == sourceIllegal) {
+    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
+    fflush(stderr);
+}
+#endif
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
+		     0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow.  There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+/* --------------------------------------------------------------------- */
+
+/* The interface converts a whole buffer to avoid function-call overhead.
+ * Constants have been gathered. Loops & conditionals have been removed as
+ * much as possible for efficiency, in favor of drop-through switches.
+ * (See "Note A" at the bottom of the file for equivalent code.)
+ * If your compiler supports it, the "isLegalUTF8" call can be turned
+ * into an inline function.
+ */
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF16toUTF8 (
+	const UTF16** sourceStart, const UTF16* sourceEnd, 
+	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF16* source = *sourceStart;
+    UTF8* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	unsigned short bytesToWrite = 0;
+	const UTF32 byteMask = 0xBF;
+	const UTF32 byteMark = 0x80; 
+	const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
+	ch = *source++;
+	/* If we have a surrogate pair, convert to UTF32 first. */
+	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+	    /* If the 16 bits following the high surrogate are in the source buffer... */
+	    if (source < sourceEnd) {
+		UTF32 ch2 = *source;
+		/* If it's a low surrogate, convert to UTF32. */
+		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
+		    ++source;
+		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		}
+	    } else { /* We don't have the 16 bits following the high surrogate. */
+		--source; /* return to the high surrogate */
+		result = sourceExhausted;
+		break;
+	    }
+	} else if (flags == strictConversion) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	/* Figure out how many bytes the result will require */
+	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
+	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
+	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
+	} else if (ch < (UTF32)0x110000) {  bytesToWrite = 4;
+	} else {			    bytesToWrite = 3;
+					    ch = UNI_REPLACEMENT_CHAR;
+	}
+
+	target += bytesToWrite;
+	if (target > targetEnd) {
+	    source = oldSource; /* Back up source pointer! */
+	    target -= bytesToWrite; result = targetExhausted; break;
+	}
+	switch (bytesToWrite) { /* note: everything falls through. */
+	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
+	}
+	target += bytesToWrite;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * If not calling this from ConvertUTF8to*, then the length can be set by:
+ *  length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns false.  The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+
+static Boolean isLegalUTF8(const UTF8 *source, int length) {
+    UTF8 a;
+    const UTF8 *srcptr = source+length;
+    switch (length) {
+    default: return false;
+	/* Everything else falls through when "true"... */
+    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+    case 2: if ((a = (*--srcptr)) > 0xBF) return false;
+
+	switch (*source) {
+	    /* no fall-through in this inner switch */
+	    case 0xE0: if (a < 0xA0) return false; break;
+	    case 0xED: if (a > 0x9F) return false; break;
+	    case 0xF0: if (a < 0x90) return false; break;
+	    case 0xF4: if (a > 0x8F) return false; break;
+	    default:   if (a < 0x80) return false;
+	}
+
+    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
+    }
+    if (*source > 0xF4) return false;
+    return true;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Exported function to return whether a UTF-8 sequence is legal or not.
+ * This is not used here; it's just exported.
+ */
+Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
+    int length = trailingBytesForUTF8[*source]+1;
+    if (source+length > sourceEnd) {
+	return false;
+    }
+    return isLegalUTF8(source, length);
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF8toUTF16 (
+	const UTF8** sourceStart, const UTF8* sourceEnd, 
+	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF8* source = *sourceStart;
+    UTF16* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch = 0;
+	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+	if (source + extraBytesToRead >= sourceEnd) {
+	    result = sourceExhausted; break;
+	}
+	/* Do this check whether lenient or strict */
+	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	    result = sourceIllegal;
+	    break;
+	}
+	/*
+	 * The cases all fall through. See "Note A" below.
+	 */
+	switch (extraBytesToRead) {
+	    case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+	    case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+	    case 3: ch += *source++; ch <<= 6;
+	    case 2: ch += *source++; ch <<= 6;
+	    case 1: ch += *source++; ch <<= 6;
+	    case 0: ch += *source++;
+	}
+	ch -= offsetsFromUTF8[extraBytesToRead];
+
+	if (target >= targetEnd) {
+	    source -= (extraBytesToRead+1); /* Back up source pointer! */
+	    result = targetExhausted; break;
+	}
+	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = (UTF16)ch; /* normal case */
+	    }
+	} else if (ch > UNI_MAX_UTF16) {
+	    if (flags == strictConversion) {
+		result = sourceIllegal;
+		source -= (extraBytesToRead+1); /* return to the start */
+		break; /* Bail out; shouldn't continue */
+	    } else {
+		*target++ = UNI_REPLACEMENT_CHAR;
+	    }
+	} else {
+	    /* target is a character in range 0xFFFF - 0x10FFFF. */
+	    if (target + 1 >= targetEnd) {
+		source -= (extraBytesToRead+1); /* Back up source pointer! */
+		result = targetExhausted; break;
+	    }
+	    ch -= halfBase;
+	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
+	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF32toUTF8 (
+	const UTF32** sourceStart, const UTF32* sourceEnd, 
+	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF32* source = *sourceStart;
+    UTF8* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	unsigned short bytesToWrite = 0;
+	const UTF32 byteMask = 0xBF;
+	const UTF32 byteMark = 0x80; 
+	ch = *source++;
+	if (flags == strictConversion ) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	/*
+	 * Figure out how many bytes the result will require. Turn any
+	 * illegally large UTF32 things (> Plane 17) into replacement chars.
+	 */
+	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
+	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
+	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
+	} else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
+	} else {			    bytesToWrite = 3;
+					    ch = UNI_REPLACEMENT_CHAR;
+					    result = sourceIllegal;
+	}
+	
+	target += bytesToWrite;
+	if (target > targetEnd) {
+	    --source; /* Back up source pointer! */
+	    target -= bytesToWrite; result = targetExhausted; break;
+	}
+	switch (bytesToWrite) { /* note: everything falls through. */
+	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
+	}
+	target += bytesToWrite;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF8toUTF32 (
+	const UTF8** sourceStart, const UTF8* sourceEnd, 
+	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF8* source = *sourceStart;
+    UTF32* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch = 0;
+	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+	if (source + extraBytesToRead >= sourceEnd) {
+	    result = sourceExhausted; break;
+	}
+	/* Do this check whether lenient or strict */
+	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	    result = sourceIllegal;
+	    break;
+	}
+	/*
+	 * The cases all fall through. See "Note A" below.
+	 */
+	switch (extraBytesToRead) {
+	    case 5: ch += *source++; ch <<= 6;
+	    case 4: ch += *source++; ch <<= 6;
+	    case 3: ch += *source++; ch <<= 6;
+	    case 2: ch += *source++; ch <<= 6;
+	    case 1: ch += *source++; ch <<= 6;
+	    case 0: ch += *source++;
+	}
+	ch -= offsetsFromUTF8[extraBytesToRead];
+
+	if (target >= targetEnd) {
+	    source -= (extraBytesToRead+1); /* Back up the source pointer! */
+	    result = targetExhausted; break;
+	}
+	if (ch <= UNI_MAX_LEGAL_UTF32) {
+	    /*
+	     * UTF-16 surrogate values are illegal in UTF-32, and anything
+	     * over Plane 17 (> 0x10FFFF) is illegal.
+	     */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = ch;
+	    }
+	} else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
+	    result = sourceIllegal;
+	    *target++ = UNI_REPLACEMENT_CHAR;
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* ---------------------------------------------------------------------
+
+    Note A.
+    The fall-through switches in UTF-8 reading code save a
+    temp variable, some decrements & conditionals.  The switches
+    are equivalent to the following loop:
+	{
+	    int tmpBytesToRead = extraBytesToRead+1;
+	    do {
+		ch += *source++;
+		--tmpBytesToRead;
+		if (tmpBytesToRead) ch <<= 6;
+	    } while (tmpBytesToRead > 0);
+	}
+    In UTF-8 writing code, the switches on "bytesToWrite" are
+    similarly unrolled loops.
+
+   --------------------------------------------------------------------- */
diff --git a/ConvertUTF.h b/ConvertUTF.h
new file mode 100644
index 0000000..e264915
--- /dev/null
+++ b/ConvertUTF.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+    Conversions between UTF32, UTF-16, and UTF-8.  Header file.
+
+    Several funtions are included here, forming a complete set of
+    conversions between the three formats.  UTF-7 is not included
+    here, but is handled in a separate source file.
+
+    Each of these routines takes pointers to input buffers and output
+    buffers.  The input buffers are const.
+
+    Each routine converts the text between *sourceStart and sourceEnd,
+    putting the result into the buffer between *targetStart and
+    targetEnd. Note: the end pointers are *after* the last item: e.g. 
+    *(sourceEnd - 1) is the last item.
+
+    The return result indicates whether the conversion was successful,
+    and if not, whether the problem was in the source or target buffers.
+    (Only the first encountered problem is indicated.)
+
+    After the conversion, *sourceStart and *targetStart are both
+    updated to point to the end of last text successfully converted in
+    the respective buffers.
+
+    Input parameters:
+	sourceStart - pointer to a pointer to the source buffer.
+		The contents of this are modified on return so that
+		it points at the next thing to be converted.
+	targetStart - similarly, pointer to pointer to the target buffer.
+	sourceEnd, targetEnd - respectively pointers to the ends of the
+		two buffers, for overflow checking only.
+
+    These conversion functions take a ConversionFlags argument. When this
+    flag is set to strict, both irregular sequences and isolated surrogates
+    will cause an error.  When the flag is set to lenient, both irregular
+    sequences and isolated surrogates are converted.
+
+    Whether the flag is strict or lenient, all illegal sequences will cause
+    an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
+    or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
+    must check for illegal sequences.
+
+    When the flag is set to lenient, characters over 0x10FFFF are converted
+    to the replacement character; otherwise (when the flag is set to strict)
+    they constitute an error.
+
+    Output parameters:
+	The value "sourceIllegal" is returned from some routines if the input
+	sequence is malformed.  When "sourceIllegal" is returned, the source
+	value will point to the illegal value that caused the problem. E.g.,
+	in UTF-8 when a sequence is malformed, it points to the start of the
+	malformed sequence.  
+
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+		 Fixes & updates, Sept 2001.
+
+------------------------------------------------------------------------ */
+
+/* ---------------------------------------------------------------------
+    The following 4 definitions are compiler-specific.
+    The C standard does not guarantee that wchar_t has at least
+    16 bits, so wchar_t is no less portable than unsigned short!
+    All should be unsigned values to avoid sign extension during
+    bit mask & shift operations.
+------------------------------------------------------------------------ */
+
+typedef unsigned long	UTF32;	/* at least 32 bits */
+typedef unsigned short	UTF16;	/* at least 16 bits */
+typedef unsigned char	UTF8;	/* typically 8 bits */
+typedef unsigned char	Boolean; /* 0 or 1 */
+
+/* Some fundamental constants */
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+typedef enum {
+	conversionOK, 		/* conversion successful */
+	sourceExhausted,	/* partial character in source, but hit end */
+	targetExhausted,	/* insuff. room in target for conversion */
+	sourceIllegal		/* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+	strictConversion = 0,
+	lenientConversion
+} ConversionFlags;
+
+/* This is for C++ and does no harm in C */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ConversionResult ConvertUTF8toUTF16 (
+		const UTF8** sourceStart, const UTF8* sourceEnd, 
+		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF16toUTF8 (
+		const UTF16** sourceStart, const UTF16* sourceEnd, 
+		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+		
+ConversionResult ConvertUTF8toUTF32 (
+		const UTF8** sourceStart, const UTF8* sourceEnd, 
+		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF8 (
+		const UTF32** sourceStart, const UTF32* sourceEnd, 
+		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+		
+ConversionResult ConvertUTF16toUTF32 (
+		const UTF16** sourceStart, const UTF16* sourceEnd, 
+		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF16 (
+		const UTF32** sourceStart, const UTF32* sourceEnd, 
+		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* --------------------------------------------------------------------- */
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..04dbba6
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,11 @@
+CC=gcc
+CFLAGS=-Wall
+CPPFLAGS=-Wall
+
+OBJ=testsi.o test1.o snippets.o ConvertUTF.o
+
+testsi:	$(OBJ)
+	gcc -o testsi -lstdc++ $(OBJ)
+
+clean:
+	rm -f testsi $(OBJ)
diff --git a/SimpleIni.h b/SimpleIni.h
new file mode 100644
index 0000000..b27d976
--- /dev/null
+++ b/SimpleIni.h
@@ -0,0 +1,2784 @@
+/** @mainpage

+

+    <table>

+        <tr><th>Library     <td>SimpleIni

+        <tr><th>File        <td>SimpleIni.h

+        <tr><th>Author      <td>Brodie Thiesfield <code@jellycan.com>

+        <tr><th>Source      <td>http://code.jellycan.com/simpleini/

+        <tr><th>Version     <td>4.0

+    </table>

+

+    Jump to the @link CSimpleIniTempl CSimpleIni @endlink interface documentation.

+

+    @section INTRODUCTION

+

+    This component allows an INI-style configuration file to be used on both

+    Windows and Linux/Unix. It is fast, simple and source code using this

+    component will compile unchanged on either OS.

+

+

+    @section FEATURES

+

+    - MIT Licence allows free use in all software (including GPL and commercial)

+    - multi-platform (Windows 95/98/ME/NT/2K/XP/2003, Windows CE, Linux, Unix)

+    - loading and saving of INI-style configuration files

+    - configuration files can have any newline format on all platforms

+    - liberal acceptance of file format

+        - key/values with no section

+        - removal of whitespace around sections, keys and values

+    - support for multi-line values (values with embedded newline characters)

+    - optional support for multiple keys with the same name

+    - optional case-insensitive sections and keys (for ASCII characters only)

+    - saves files with sections and keys in the same order as they were loaded

+    - preserves comments on the file, section and keys where possible.

+    - supports both char or wchar_t programming interfaces

+    - supports both MBCS (system locale) and UTF-8 file encodings

+    - system locale does not need to be UTF-8 on Linux/Unix to load UTF-8 file

+    - support for non-ASCII characters in section, keys, values and comments

+    - support for non-standard character types or file encodings

+      via user-written converter classes

+    - support for adding/modifying values programmatically

+    - compiles cleanly at warning level 4 (Windows/VC.NET 2003), warning level

+      3 (Windows/VC6) and -Wall (Linux/gcc)

+

+

+    @section USAGE SUMMARY

+

+    -#  Define the appropriate symbol for the converter you wish to use and

+        include the SimpleIni.h header file. If no specific converter is defined

+        then the default converter is used. The default conversion mode uses

+        SI_CONVERT_WIN32 on Windows and SI_CONVERT_GENERIC on all other

+        platforms. If you are using ICU then SI_CONVERT_ICU is supported on all

+        platforms.

+    -#  Declare an instance the appropriate class. Note that the following

+        definitions are just shortcuts for commonly used types. Other types

+        (PRUnichar, unsigned short, unsigned char) are also possible.

+        <table>

+            <tr><th>Interface   <th>Case-sensitive  <th>Load UTF-8  <th>Load MBCS   <th>Typedef

+        <tr><th>SI_CONVERT_GENERIC

+            <tr><td>char        <td>No              <td>Yes         <td>Yes #1      <td>CSimpleIniA

+            <tr><td>char        <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseA

+            <tr><td>wchar_t     <td>No              <td>Yes         <td>Yes         <td>CSimpleIniW

+            <tr><td>wchar_t     <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseW

+        <tr><th>SI_CONVERT_WIN32

+            <tr><td>char        <td>No              <td>No #2       <td>Yes         <td>CSimpleIniA

+            <tr><td>char        <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseA

+            <tr><td>wchar_t     <td>No              <td>Yes         <td>Yes         <td>CSimpleIniW

+            <tr><td>wchar_t     <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseW

+        <tr><th>SI_CONVERT_ICU

+            <tr><td>char        <td>No              <td>Yes         <td>Yes         <td>CSimpleIniA

+            <tr><td>char        <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseA

+            <tr><td>UChar       <td>No              <td>Yes         <td>Yes         <td>CSimpleIniW

+            <tr><td>UChar       <td>Yes             <td>Yes         <td>Yes         <td>CSimpleIniCaseW

+        </table>

+        #1  On Windows you are better to use CSimpleIniA with SI_CONVERT_WIN32.<br>

+        #2  Only affects Windows. On Windows this uses MBCS functions and

+            so may fold case incorrectly leading to uncertain results.

+    -# Call Load() or LoadFile() to load and parse the INI configuration file

+    -# Access and modify the data of the file using the following functions

+        <table>

+            <tr><td>GetAllSections  <td>Return all section names

+            <tr><td>GetAllKeys      <td>Return all key names within a section

+            <tr><td>GetAllValues    <td>Return all values within a section & key

+            <tr><td>GetSection      <td>Return all key names and values in a section

+            <tr><td>GetSectionSize  <td>Return the number of keys in a section

+            <tr><td>GetValue        <td>Return a value for a section & key

+            <tr><td>SetValue        <td>Add or update a value for a section & key

+            <tr><td>Delete          <td>Remove a section, or a key from a section

+        </table>

+    -# Call Save() or SaveFile() to save the INI configuration data

+

+    @section IO-STREAMS

+

+    SimpleIni supports reading from and writing to STL IO streams. Enable this

+    by defining SI_SUPPORT_IOSTREAMS before including the SimpleIni.h header

+    file. Ensure that if the streams are backed by a file (e.g. ifstream or

+    ofstream) then the flag ios_base::binary has been used when the file was

+    opened.

+

+    @section MULTI-LINE VALUES

+

+    Values that span multiple lines are created using the following format.

+

+        <pre>

+        key = <<<ENDTAG

+        .... multiline value ....

+        ENDTAG

+        </pre>

+

+    Note the following:

+    - The text used for ENDTAG can be anything and is used to find

+      where the multi-line text ends.

+    - The newline after ENDTAG in the start tag, and the newline

+      before ENDTAG in the end tag is not included in the data value.

+    - The ending tag must be on it's own line with no whitespace before

+      or after it.

+    - The multi-line value is not modified at load or save. This means

+      that the newline format (PC, Unix, Mac) is whatever the original

+      file uses.

+

+    @section COMMENTS

+

+    Comments are preserved in the file within the following restrictions:

+    - Every file may have a single "file comment". It must start with the

+      first character in the file, and will end with the first non-comment

+      line in the file.

+    - Every section may have a single "section comment". It will start

+      with the first comment line following the file comment, or the last

+      data entry. It ends at the beginning of the section.

+    - Every key may have a single "key comment". This comment will start

+      with the first comment line following the section start, or the file

+      comment if there is no section name.

+    - MultiKey entries may have only a single comment and will take the

+      comment associated with the first key found.

+    - Comments are set at the time that the file, section or key is first

+      created. The only way to modify a comment on a section or a key is to

+      delete that entry and recreate it with the new comment. There is no

+      way to change the file comment.

+

+    @section SAVE ORDER

+

+    The sections and keys are written out in the same order as they were

+    read in from the file. Sections and keys added to the data after the

+    file has been loaded will be added to the end of the file when it is

+    written. There is no way to specify the location of a section or key

+    other than in first-created, first-saved order.

+

+    @section NOTES

+

+    - To load UTF-8 data on Windows 95, you need to use Microsoft Layer for

+      Unicode, or SI_CONVERT_GENERIC, or SI_CONVERT_ICU.

+    - When using SI_CONVERT_GENERIC, ConvertUTF.c must be compiled and linked.

+    - When using SI_CONVERT_ICU, ICU header files must be on the include

+      path and icuuc.lib must be linked in.

+    - To load a UTF-8 file on Windows AND expose it with SI_CHAR == char,

+      you should use SI_CONVERT_GENERIC.

+    - The collation (sorting) order used for sections and keys returned from

+      iterators is NOT DEFINED. If collation order of the text is important

+      then it should be done yourself by either supplying a replacement

+      SI_STRLESS class, or by sorting the strings external to this library.

+    - Usage of the <mbstring.h> header on Windows can be disabled by defining

+      SI_NO_MBCS. This is defined automatically on Windows CE platforms.

+

+

+    @section MIT LICENCE

+

+    The licence text below is the boilerplate "MIT Licence" used from:

+    http://www.opensource.org/licenses/mit-license.php

+

+    Copyright (c) 2006, Brodie Thiesfield

+

+    Permission is hereby granted, free of charge, to any person obtaining a copy

+    of this software and associated documentation files (the "Software"), to deal

+    in the Software without restriction, including without limitation the rights

+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+    copies of the Software, and to permit persons to whom the Software is furnished

+    to do so, subject to the following conditions:

+

+    The above copyright notice and this permission notice shall be included in

+    all copies or substantial portions of the Software.

+

+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+*/

+

+#ifndef INCLUDED_SimpleIni_h

+#define INCLUDED_SimpleIni_h

+

+// Disable these warnings in MSVC:

+//  4127 "conditional expression is constant" as the conversion classes trigger

+//  it with the statement if (sizeof(SI_CHAR) == sizeof(char)). This test will

+//  be optimized away in a release build.

+//  4702 "unreachable code" as the MS STL header causes it in release mode.

+//  Again, the code causing the warning will be cleaned up by the compiler.

+//  4786 "identifier truncated to 256 characters" as this is thrown hundreds

+//  of times VC6 as soon as STL is used.

+#ifdef _MSC_VER

+# pragma warning (disable: 4127 4702 4786)

+#endif

+

+#include <string>

+#include <map>

+#include <list>

+#include <algorithm>

+#include <stdio.h>

+

+#ifdef SI_SUPPORT_IOSTREAMS

+# include <iostream>

+#endif // SI_SUPPORT_IOSTREAMS

+

+#ifdef _DEBUG

+# include <assert.h>

+# define SI_ASSERT(x)   assert(x)

+#else

+# define SI_ASSERT(x)

+#endif

+

+enum SI_Error {

+    SI_OK       =  0,   //!< No error

+    SI_UPDATED  =  1,   //!< An existing value was updated

+    SI_INSERTED =  2,   //!< A new value was inserted

+

+    // note: test for any error with (retval < 0)

+    SI_FAIL     = -1,   //!< Generic failure

+    SI_NOMEM    = -2,   //!< Out of memory error

+    SI_FILE     = -3    //!< File error (see errno for detail error)

+};

+

+#define SI_BOM_UTF8     "\xEF\xBB\xBF"

+

+#ifdef _WIN32

+# define SI_NEWLINE_A   "\r\n"

+# define SI_NEWLINE_W   L"\r\n"

+#else // !_WIN32

+# define SI_NEWLINE_A   "\n"

+# define SI_NEWLINE_W   L"\n"

+#endif // _WIN32

+

+#if defined(SI_CONVERT_ICU)

+# include <unicode/ustring.h>

+#endif

+

+#if defined(_WIN32)

+# define SI_HAS_WIDE_FILE

+# define SI_WCHAR_T     wchar_t

+#elif defined(SI_CONVERT_ICU)

+# define SI_HAS_WIDE_FILE

+# define SI_WCHAR_T     UChar

+#endif

+

+

+// ---------------------------------------------------------------------------

+//                              MAIN TEMPLATE CLASS

+// ---------------------------------------------------------------------------

+

+/** Simple INI file reader.

+

+    This can be instantiated with the choice of unicode or native characterset,

+    and case sensitive or insensitive comparisons of section and key names.

+    The supported combinations are pre-defined with the following typedefs:

+

+    <table>

+        <tr><th>Interface   <th>Case-sensitive  <th>Typedef

+        <tr><td>char        <td>No              <td>CSimpleIniA

+        <tr><td>char        <td>Yes             <td>CSimpleIniCaseA

+        <tr><td>wchar_t     <td>No              <td>CSimpleIniW

+        <tr><td>wchar_t     <td>Yes             <td>CSimpleIniCaseW

+    </table>

+

+    Note that using other types for the SI_CHAR is supported. For instance,

+    unsigned char, unsigned short, etc. Note that where the alternative type

+    is a different size to char/wchar_t you may need to supply new helper

+    classes for SI_STRLESS and SI_CONVERTER.

+ */

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+class CSimpleIniTempl

+{

+public:

+    /** key entry */

+    struct Entry {

+        const SI_CHAR * pItem;

+        const SI_CHAR * pComment;

+        int             nOrder;

+

+        Entry(const SI_CHAR * a_pszItem = NULL, int a_nOrder = 0)

+            : pItem(a_pszItem)

+            , pComment(NULL)

+            , nOrder(a_nOrder)

+        { }

+        Entry(const Entry & rhs) { operator=(rhs); }

+        Entry & operator=(const Entry & rhs) {

+            pItem     = rhs.pItem;

+            pComment = rhs.pComment;

+            nOrder     = rhs.nOrder;

+            return *this;

+        }

+

+#if defined(_MSC_VER) && _MSC_VER <= 1200

+        /** STL of VC6 doesn't allow me to specify my own comparator for list::sort() */

+        bool operator<(const Entry & rhs) const { return LoadOrder()(*this, rhs); }

+        bool operator>(const Entry & rhs) const { return LoadOrder()(rhs, *this); }

+#endif

+

+        /** Strict less ordering by name of key only */

+        struct KeyOrder : std::binary_function<Entry, Entry, bool> {

+            bool operator()(const Entry & lhs, const Entry & rhs) const {

+                const static SI_STRLESS isLess = SI_STRLESS();

+                return isLess(lhs.pItem, rhs.pItem);

+            }

+        };

+

+        /** Strict less ordering by order, and then name of key */

+        struct LoadOrder : std::binary_function<Entry, Entry, bool> {

+            bool operator()(const Entry & lhs, const Entry & rhs) const {

+                if (lhs.nOrder != rhs.nOrder) {

+                    return lhs.nOrder < rhs.nOrder;

+                }

+                return KeyOrder()(lhs.pItem, rhs.pItem);

+            }

+        };

+    };

+

+    /** map keys to values */

+    typedef std::multimap<Entry,const SI_CHAR *,Entry::KeyOrder> TKeyVal;

+

+    /** map sections to key/value map */

+    typedef std::map<Entry,TKeyVal,Entry::KeyOrder> TSection;

+

+    /** set of dependent string pointers. Note that these pointers are

+        dependent on memory owned by CSimpleIni.

+    */

+    typedef std::list<Entry> TNamesDepend;

+

+    /** interface definition for the OutputWriter object to pass to Save()

+        in order to output the INI file data.

+    */

+    class OutputWriter {

+    public:

+        OutputWriter() { }

+        virtual ~OutputWriter() { }

+        virtual void Write(const char * a_pBuf) = 0;

+    private:

+        OutputWriter(const OutputWriter &);             // disable

+        OutputWriter & operator=(const OutputWriter &); // disable

+    };

+

+    /** OutputWriter class to write the INI data to a file */

+    class FileWriter : public OutputWriter {

+        FILE * m_file;

+    public:

+        FileWriter(FILE * a_file) : m_file(a_file) { }

+        void Write(const char * a_pBuf) {

+            fputs(a_pBuf, m_file);

+        }

+    private:

+        FileWriter(const FileWriter &);             // disable

+        FileWriter & operator=(const FileWriter &); // disable

+    };

+

+    /** OutputWriter class to write the INI data to a string */

+    class StringWriter : public OutputWriter {

+        std::string & m_string;

+    public:

+        StringWriter(std::string & a_string) : m_string(a_string) { }

+        void Write(const char * a_pBuf) {

+            m_string.append(a_pBuf);

+        }

+    private:

+        StringWriter(const StringWriter &);             // disable

+        StringWriter & operator=(const StringWriter &); // disable

+    };

+

+#ifdef SI_SUPPORT_IOSTREAMS

+    /** OutputWriter class to write the INI data to an ostream */

+    class StreamWriter : public OutputWriter {

+        std::ostream & m_ostream;

+    public:

+        StreamWriter(std::ostream & a_ostream) : m_ostream(a_ostream) { }

+        void Write(const char * a_pBuf) {

+            m_ostream << a_pBuf;

+        }

+    private:

+        StreamWriter(const StreamWriter &);             // disable

+        StreamWriter & operator=(const StreamWriter &); // disable

+    };

+#endif // SI_SUPPORT_IOSTREAMS

+

+    /** Characterset conversion utility class to convert strings to the

+        same format as is used for the storage.

+    */

+    template <class SI_CHAR>

+    class ConverterTempl : private SI_CONVERTER {

+    public:

+        ConverterTempl(bool a_bStoreIsUtf8) : SI_CONVERTER(a_bStoreIsUtf8) {

+            m_scratch.resize(1024);

+        }

+        ConverterTempl(const ConverterTempl & rhs) { operator=(rhs); }

+        ConverterTempl & operator=(const ConverterTempl & rhs) {

+            m_scratch = rhs.m_scratch;

+            return *this;

+        }

+        bool ConvertToStore(const SI_CHAR * a_pszString) {

+            size_t uLen = SizeToStore(a_pszString);

+            if (uLen == (size_t)(-1)) {

+                return false;

+            }

+            while (uLen > m_scratch.size()) {

+                m_scratch.resize(m_scratch.size() * 2);

+            }

+            return SI_CONVERTER::ConvertToStore(

+                a_pszString,

+                const_cast<char*>(m_scratch.data()),

+                m_scratch.size());

+        }

+        const char * Data() { return m_scratch.data(); }

+    private:

+        std::string m_scratch;

+    };

+    typedef ConverterTempl<SI_CHAR> Converter;

+

+public:

+    /*-----------------------------------------------------------------------*/

+    /** @{ @name Construction and Settings */

+

+    /** Default constructor.

+

+        @param a_bIsUtf8     See the method SetUnicode() for details.

+        @param a_bMultiKey   See the method SetMultiKey() for details.

+        @param a_bMultiLine  See the method SetMultiLine() for details.

+     */

+    CSimpleIniTempl(

+        bool a_bIsUtf8 = false,

+        bool a_bMultiKey = false,

+        bool a_bMultiLine = false

+        );

+

+    /** Destructor */

+    ~CSimpleIniTempl();

+

+    /** Deallocate all memory stored by this object */

+    void Reset();

+

+    /** Set the storage format of the INI data. This affects both the loading

+        and saving of the INI data using all of the Load/Save API functions.

+        This value cannot be changed after any INI data has been loaded.

+

+        If the file is not set to Unicode (UTF-8), then the data encoding is

+        assumed to be the OS native encoding. This encoding is the system

+        locale on Linux/Unix and the legacy MBCS encoding on Windows NT/2K/XP.

+        If the storage format is set to Unicode then the file will be loaded

+        as UTF-8 encoded data regardless of the native file encoding. If

+        SI_CHAR == char then all of the char* parameters take and return UTF-8

+        encoded data regardless of the system locale.

+

+        \param a_bIsUtf8     Assume UTF-8 encoding for the source?

+     */

+    void SetUnicode(bool a_bIsUtf8 = true) {

+        if (!m_pData) m_bStoreIsUtf8 = a_bIsUtf8;

+    }

+

+    /** Get the storage format of the INI data. */

+    bool IsUnicode() const { return m_bStoreIsUtf8; }

+

+    /** Should multiple identical keys be permitted in the file. If set to false

+        then the last value encountered will be used as the value of the key.

+        If set to true, then all values will be available to be queried. For

+        example, with the following input:

+

+        <pre>

+        [section]

+        test=value1

+        test=value2

+        </pre>

+

+        Then with SetMultiKey(true), both of the values "value1" and "value2"

+        will be returned for the key test. If SetMultiKey(false) is used, then

+        the value for "test" will only be "value2". This value may be changed

+        at any time.

+

+        \param a_bAllowMultiKey  Allow multi-keys in the source?

+     */

+    void SetMultiKey(bool a_bAllowMultiKey = true) {

+        m_bAllowMultiKey = a_bAllowMultiKey;

+    }

+

+    /** Get the storage format of the INI data. */

+    bool IsMultiKey() const { return m_bAllowMultiKey; }

+

+    /** Should data values be permitted to span multiple lines in the file. If

+        set to false then the multi-line construct <<<TAG as a value will be

+        returned as is instead of loading the data. This value may be changed

+        at any time.

+

+        \param a_bAllowMultiLine     Allow multi-line values in the source?

+     */

+    void SetMultiLine(bool a_bAllowMultiLine = true) {

+        m_bAllowMultiLine = a_bAllowMultiLine;

+    }

+

+    /** Query the status of multi-line data */

+    bool IsMultiLine() const { return m_bAllowMultiLine; }

+

+    /*-----------------------------------------------------------------------*/

+    /** @}

+        @{ @name Loading INI Data */

+

+    /** Load an INI file from disk into memory

+

+        @param a_pszFile    Path of the file to be loaded. This will be passed

+                            to fopen() and so must be a valid path for the

+                            current platform.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error LoadFile(

+        const char * a_pszFile

+        );

+

+#ifdef SI_HAS_WIDE_FILE

+    /** Load an INI file from disk into memory

+

+        @param a_pwszFile   Path of the file to be loaded in UTF-16.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error LoadFile(

+        const SI_WCHAR_T * a_pwszFile

+        );

+#endif // SI_HAS_WIDE_FILE

+

+    /** Load the file from a file pointer.

+

+        @param a_fpFile     Valid file pointer to read the file data from. The

+                            file will be read until end of file.

+

+        @return SI_Error    See error definitions

+    */

+    SI_Error LoadFile(

+        FILE * a_fpFile

+        );

+

+#ifdef SI_SUPPORT_IOSTREAMS

+    /** Load INI file data from an istream.

+

+        @param a_istream    Stream to read from

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Load(

+        std::istream & a_istream

+        );

+#endif // SI_SUPPORT_IOSTREAMS

+

+    /** Load INI file data direct from a std::string

+

+        @param a_strData    Data to be loaded

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Load(const std::string & a_strData) {

+        return Load(a_strData.c_str(), a_strData.size());

+    }

+

+    /** Load INI file data direct from memory

+

+        @param a_pData      Data to be loaded

+        @param a_uDataLen   Length of the data in bytes

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Load(

+        const char *    a_pData,

+        size_t          a_uDataLen

+        );

+

+    /*-----------------------------------------------------------------------*/

+    /** @}

+        @{ @name Saving INI Data */

+

+    /** Save an INI file from memory to disk

+

+        @param a_pszFile    Path of the file to be saved. This will be passed

+                            to fopen() and so must be a valid path for the

+                            current platform.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error SaveFile(

+        const char * a_pszFile

+        );

+

+#ifdef SI_HAS_WIDE_FILE

+    /** Save an INI file from memory to disk

+

+        @param a_pwszFile   Path of the file to be saved in UTF-16.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error SaveFile(

+        const SI_WCHAR_T * a_pwszFile

+        );

+#endif // _WIN32

+

+    /**

+     * Save the INI data to a file. See Save() for details. Do not set

+     * a_bUseBOM to true if any information has been written to the file

+     * prior to calling this method.

+     *

+     * @param a_pFile       Handle to a file. File should be opened for

+     *                      binary output.

+     * @param a_bUseBOM     Prepend the UTF-8 BOM if the output data is

+     *                      in UTF-8 format.

+     */

+    SI_Error SaveFile(

+        FILE *  a_pFile,

+        bool    a_bUseBOM = false

+        ) const;

+

+    /** Save the INI data. The data will be written to the output device

+        in a format appropriate to the current data, selected by:

+

+        <table>

+            <tr><th>SI_CHAR     <th>FORMAT

+            <tr><td>char        <td>same format as when loaded (MBCS or UTF-8)

+            <tr><td>wchar_t     <td>UTF-8

+            <tr><td>other       <td>UTF-8

+        </table>

+

+        Note that comments, etc from the original data are not preserved. Only

+        valid data contents stored in the file are written out. The order of

+        the sections and values from the original file will be preserved.

+

+        Any data prepended or appended to the output device must use the the

+        same format (MBCS or UTF-8). You may use the GetConverter() method to

+        convert text to the correct format regardless of the output format

+        being used by SimpleIni.

+

+        To add a BOM to UTF-8 data, write it out manually at the very beginning

+        like is done in SaveFile when a_bUseBOM is true.

+

+        @param a_oOutput    Output writer to write the data to.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Save(

+        OutputWriter & a_oOutput

+        ) const;

+

+#ifdef SI_SUPPORT_IOSTREAMS

+    /** Save the INI data to an ostream. See Save() for details.

+

+        @param a_ostream    String to have the INI data appended to.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Save(

+        std::ostream & a_ostream

+        ) const

+    {

+        StreamWriter writer(a_ostream);

+        return Save(writer);

+    }

+#endif // SI_SUPPORT_IOSTREAMS

+

+    /** Save the INI data to a string. See Save() for details.

+

+        @param a_sBuffer    String to have the INI data appended to.

+

+        @return SI_Error    See error definitions

+     */

+    SI_Error Save(

+        std::string & a_sBuffer

+        ) const

+    {

+        StringWriter writer(a_sBuffer);

+        return Save(writer);

+    }

+

+    /*-----------------------------------------------------------------------*/

+    /** @}

+        @{ @name Accessing INI Data */

+

+    /** Retrieve the value for a specific key. If multiple keys are enabled

+        (see SetMultiKey) then only the first value associated with that key

+        will be returned, see GetAllValues for getting all values with multikey.

+

+        NOTE! The returned value is a pointer to string data stored in memory

+        owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed

+        or Reset while you are using this pointer!

+

+        @param a_pSection       Section to search

+        @param a_pKey           Key to search for

+        @param a_pDefault       Value to return if the key is not found

+        @param a_pHasMultiple   Optionally receive notification of if there are

+                                multiple entries for this key.

+

+        @return a_pDefault      Key was not found in the section

+        @return other           Value of the key

+     */

+    const SI_CHAR * GetValue(

+        const SI_CHAR * a_pSection,

+        const SI_CHAR * a_pKey,

+        const SI_CHAR * a_pDefault     = NULL,

+        bool *          a_pHasMultiple = NULL

+        ) const;

+

+    /** Retrieve all values for a specific key. This method can be used when

+        multiple keys are both enabled and disabled.

+

+        NOTE! The returned values are pointers to string data stored in memory

+        owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed

+        or Reset while you are using this pointer!

+

+        @param a_pSection       Section to search

+        @param a_pKey           Key to search for

+        @param a_values         List to return if the key is not found

+

+        @return a_pDefault      Key was not found in the section

+        @return other           Value of the key

+     */

+    bool GetAllValues(

+        const SI_CHAR * a_pSection,

+        const SI_CHAR * a_pKey,

+        TNamesDepend &  a_values

+        ) const;

+

+    /** Add or update a section or value. This will always insert

+        when multiple keys are enabled.

+

+        @param a_pSection   Section to add or update

+        @param a_pKey       Key to add or update. Set to NULL to

+                            create an empty section.

+        @param a_pValue     Value to set. Set to NULL to create an

+                            empty section.

+        @param a_pComment   Comment to be associated with the section or the

+                            key. If a_pKey is NULL then it will be associated

+                            with the section, otherwise the key. Note that a

+                            comment may be set ONLY when the section or key is

+                            first created (i.e. when this function returns the

+                            value SI_INSERTED). If you wish to create a section

+                            with a comment then you need to create the section

+                            separately to the key. The comment string must be

+                            in full comment form already (have a comment

+                            character starting every line).

+

+        @return SI_Error    See error definitions

+        @return SI_UPDATED  Value was updated

+        @return SI_INSERTED Value was inserted

+     */

+    SI_Error SetValue(

+        const SI_CHAR * a_pSection,

+        const SI_CHAR * a_pKey,

+        const SI_CHAR * a_pValue,

+        const SI_CHAR * a_pComment = NULL

+        )

+    {

+        return AddEntry(a_pSection, a_pKey, a_pValue, a_pComment, true);

+    }

+

+    /** Delete an entire section, or a key from a section. Note that the

+        data returned by GetSection is invalid and must not be used after

+        anything has been deleted from that section using this method.

+        Note when multiple keys is enabled, this will delete all keys with

+        that name; there is no way to selectively delete individual key/values

+        in this situation.

+

+        @param a_pSection       Section to delete key from, or if

+                                a_pKey is NULL, the section to remove.

+        @param a_pKey           Key to remove from the section. Set to

+                                NULL to remove the entire section.

+        @param a_bRemoveEmpty   If the section is empty after this key has

+                                been deleted, should the empty section be

+                                removed?

+

+        @return true            Key or section was deleted.

+        @return false           Key or section was not found.

+     */

+    bool Delete(

+        const SI_CHAR * a_pSection,

+        const SI_CHAR * a_pKey,

+        bool            a_bRemoveEmpty = false

+        );

+

+    /** Query the number of keys in a specific section. Note that if multiple

+        keys are enabled, then this value may be different to the number of

+        keys returned by GetAllKeys.

+

+        @param a_pSection       Section to request data for

+

+        @return -1              Section does not exist in the file

+        @return >=0             Number of keys in the section

+     */

+    int GetSectionSize(

+        const SI_CHAR * a_pSection

+        ) const;

+

+    /** Retrieve all key and value pairs for a section. The data is returned

+        as a pointer to an STL map and can be iterated or searched as

+        desired. Note that multiple entries for the same key may exist when

+        multiple keys have been enabled.

+

+        NOTE! This structure contains only pointers to strings. The actual

+        string data is stored in memory owned by CSimpleIni. Ensure that the

+        CSimpleIni object is not destroyed or Reset() while these strings

+        are in use!

+

+        @param a_pSection       Name of the section to return

+        @return boolean         Was a section matching the supplied

+                                name found.

+     */

+    const TKeyVal * GetSection(

+        const SI_CHAR * a_pSection

+        ) const;

+

+    /** Retrieve all section names. The list is returned as an STL vector of

+        names and can be iterated or searched as necessary. Note that the

+        collation order of the returned strings is NOT DEFINED.

+

+        NOTE! This structure contains only pointers to strings. The actual

+        string data is stored in memory owned by CSimpleIni. Ensure that the

+        CSimpleIni object is not destroyed or Reset() while these pointers

+        are in use!

+

+        @param a_names          Vector that will receive all of the section

+                                names. See note above!

+     */

+    void GetAllSections(

+        TNamesDepend & a_names

+        ) const;

+

+    /** Retrieve all unique key names in a section. The collation order of the

+        returned strings is NOT DEFINED. Only unique key names are returned.

+

+        NOTE! This structure contains only pointers to strings. The actual

+        string data is stored in memory owned by CSimpleIni. Ensure that the

+        CSimpleIni object is not destroyed or Reset() while these strings

+        are in use!

+

+        @param a_pSection       Section to request data for

+        @param a_names          List that will receive all of the key

+                                names. See note above!

+     */

+    void GetAllKeys(

+        const SI_CHAR * a_pSection,

+        TNamesDepend &  a_names

+        ) const;

+

+    /*-----------------------------------------------------------------------*/

+    /** @}

+        @{ @name Converter */

+

+    /** Return a conversion object to convert text to the same encoding

+        as is used by the Save(), SaveFile() and SaveString() functions.

+        Use this to prepare the strings that you wish to append or prepend

+        to the output INI data.

+     */

+    Converter GetConverter() const {

+        return Converter(m_bStoreIsUtf8);

+    }

+

+    /*-----------------------------------------------------------------------*/

+    /** @} */

+

+private:

+    /** Parse the data looking for a file comment and store it if found.

+    */

+    SI_Error FindFileComment(

+        SI_CHAR *&      a_pData,

+        bool            a_bCopyStrings

+        );

+

+    /** Parse the data looking for the next valid entry. The memory pointed to

+        by a_pData is modified by inserting NULL characters. The pointer is

+        updated to the current location in the block of text.

+    */

+    bool FindEntry(

+        SI_CHAR *&  a_pData,

+        const SI_CHAR *&  a_pSection,

+        const SI_CHAR *&  a_pKey,

+        const SI_CHAR *&  a_pVal,

+        const SI_CHAR *&  a_pComment

+        ) const;

+

+    /** Add the section/key/value to our data.

+

+        @param a_pSection   Section name. Sections will be created if they

+                            don't already exist.

+        @param a_pKey       Key name. May be NULL to create an empty section.

+                            Existing entries will be updated. New entries will

+                            be created.

+        @param a_pValue     Value for the key.

+        @param a_pComment   Comment to be associated with the section or the

+                            key. If a_pKey is NULL then it will be associated

+                            with the section, otherwise the key. This must be

+                            a string in full comment form already (have a

+                            comment character starting every line).

+        @param a_bCopyStrings   Should copies of the strings be made or not.

+                            If false then the pointers will be used as is.

+    */

+    SI_Error AddEntry(

+        const SI_CHAR * a_pSection,

+        const SI_CHAR * a_pKey,

+        const SI_CHAR * a_pValue,

+        const SI_CHAR * a_pComment,

+        bool            a_bCopyStrings

+        );

+

+    /** Is the supplied character a whitespace character? */

+    inline bool IsSpace(SI_CHAR ch) const {

+        return (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n');

+    }

+

+    /** Does the supplied character start a comment line? */

+    inline bool IsComment(SI_CHAR ch) const {

+        return (ch == ';' || ch == '#');

+    }

+

+

+    /** Skip over a newline character (or characters) for either DOS or UNIX */

+    inline void SkipNewLine(const SI_CHAR *& a_pData) const {

+        a_pData += (*a_pData == '\r' && *(a_pData+1) == '\n') ? 2 : 1;

+    }

+

+    /** Make a copy of the supplied string, replacing the original pointer */

+    SI_Error CopyString(const SI_CHAR *& a_pString);

+

+    /** Delete a string from the copied strings buffer if necessary */

+    void DeleteString(const SI_CHAR * a_pString);

+

+    /** Internal use of our string comparison function */

+    bool IsLess(const SI_CHAR * a_pLeft, const SI_CHAR * a_pRight) const {

+        const static SI_STRLESS isLess = SI_STRLESS();

+        return isLess(a_pLeft, a_pRight);

+    }

+

+    bool IsMultiLineTag(const SI_CHAR * a_pData) const;

+    bool IsMultiLineData(const SI_CHAR * a_pData) const;

+    bool FindMultiLine(SI_CHAR *& a_pData, const SI_CHAR *& a_pVal) const;

+    bool IsNewLineChar(SI_CHAR a_c) const;

+

+private:

+    /** Copy of the INI file data in our character format. This will be

+        modified when parsed to have NULL characters added after all

+        interesting string entries. All of the string pointers to sections,

+        keys and values point into this block of memory.

+     */

+    SI_CHAR * m_pData;

+

+    /** Length of the data that we have stored. Used when deleting strings

+        to determine if the string is stored here or in the allocated string

+        buffer.

+     */

+    size_t m_uDataLen;

+

+    /** File comment for this data, if one exists. */

+    SI_CHAR * m_pFileComment;

+

+    /** Parsed INI data. Section -> (Key -> Value). */

+    TSection m_data;

+

+    /** This vector stores allocated memory for copies of strings that have

+        been supplied after the file load. It will be empty unless SetValue()

+        has been called.

+     */

+    TNamesDepend m_strings;

+

+    /** Is the format of our datafile UTF-8 or MBCS? */

+    bool m_bStoreIsUtf8;

+

+    /** Are multiple values permitted for the same key? */

+    bool m_bAllowMultiKey;

+

+    /** Are data values permitted to span multiple lines? */

+    bool m_bAllowMultiLine;

+

+    /** Next order value, used to ensure sections and keys are output in the

+        same order that they are loaded/added.

+     */

+    int m_nOrder;

+};

+

+// ---------------------------------------------------------------------------

+//                                  IMPLEMENTATION

+// ---------------------------------------------------------------------------

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::CSimpleIniTempl(

+    bool a_bIsUtf8,

+    bool a_bAllowMultiKey,

+    bool a_bAllowMultiLine

+    )

+  : m_pData(0)

+  , m_uDataLen(0)

+  , m_pFileComment(NULL)

+  , m_bStoreIsUtf8(a_bIsUtf8)

+  , m_bAllowMultiKey(a_bAllowMultiKey)

+  , m_bAllowMultiLine(a_bAllowMultiLine)

+  , m_nOrder(0)

+{ }

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::~CSimpleIniTempl()

+{

+    Reset();

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+void

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::Reset()

+{

+    // remove all data

+    delete[] m_pData;

+    m_pData = NULL;

+    m_uDataLen = 0;

+    m_pFileComment = NULL;

+    if (!m_data.empty()) {

+        m_data.erase(m_data.begin(), m_data.end());

+    }

+

+    // remove all strings

+    if (!m_strings.empty()) {

+        typename TNamesDepend::iterator i = m_strings.begin();

+        for (; i != m_strings.end(); ++i) {

+            delete[] const_cast<SI_CHAR*>(i->pItem);

+        }

+        m_strings.erase(m_strings.begin(), m_strings.end());

+    }

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::LoadFile(

+    const char * a_pszFile

+    )

+{

+    FILE * fp = fopen(a_pszFile, "rb");

+    if (!fp) {

+        return SI_FILE;

+    }

+    SI_Error rc = LoadFile(fp);

+    fclose(fp);

+    return rc;

+}

+

+#ifdef SI_HAS_WIDE_FILE

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::LoadFile(

+    const SI_WCHAR_T * a_pwszFile

+    )

+{

+#ifdef _WIN32

+    FILE * fp = _wfopen(a_pwszFile, L"rb");

+    if (!fp) return SI_FILE;

+    SI_Error rc = LoadFile(fp);

+    fclose(fp);

+    return rc;

+#else // SI_CONVERT_ICU

+    char szFile[256];

+    u_austrncpy(szFile, a_pwszFile, sizeof(szFile));

+    return LoadFile(szFile);

+#endif

+}

+#endif // SI_HAS_WIDE_FILE

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::LoadFile(

+    FILE * a_fpFile

+    )

+{

+    // load the raw file data

+    int retval = fseek(a_fpFile, 0, SEEK_END);

+    if (retval != 0) {

+        return SI_FILE;

+    }

+    long lSize = ftell(a_fpFile);

+    if (lSize < 0) {

+        return SI_FILE;

+    }

+    char * pData = new char[lSize];

+    if (!pData) {

+        return SI_NOMEM;

+    }

+    fseek(a_fpFile, 0, SEEK_SET);

+    size_t uRead = fread(pData, sizeof(char), lSize, a_fpFile);

+    if (uRead != (size_t) lSize) {

+        delete[] pData;

+        return SI_FILE;

+    }

+

+    // convert the raw data to unicode

+    SI_Error rc = Load(pData, uRead);

+    delete[] pData;

+    return rc;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::Load(

+    const char *    a_pData,

+    size_t          a_uDataLen

+    )

+{

+    SI_CONVERTER converter(m_bStoreIsUtf8);

+

+    // consume the UTF-8 BOM if it exists

+    if (m_bStoreIsUtf8 && a_uDataLen >= 3) {

+        if (memcmp(a_pData, SI_BOM_UTF8, 3) == 0) {

+            a_pData    += 3;

+            a_uDataLen -= 3;

+        }

+    }

+

+    // determine the length of the converted data

+    size_t uLen = converter.SizeFromStore(a_pData, a_uDataLen);

+    if (uLen == (size_t)(-1)) {

+        return SI_FAIL;

+    }

+

+    // allocate memory for the data, ensure that there is a NULL

+    // terminator wherever the converted data ends

+    SI_CHAR * pData = new SI_CHAR[uLen+1];

+    if (!pData) {

+        return SI_NOMEM;

+    }

+    memset(pData, 0, sizeof(SI_CHAR)*(uLen+1));

+

+    // convert the data

+    if (!converter.ConvertFromStore(a_pData, a_uDataLen, pData, uLen)) {

+        delete[] pData;

+        return SI_FAIL;

+    }

+

+    // parse it

+    const static SI_CHAR empty = 0;

+    SI_CHAR * pWork = pData;

+    const SI_CHAR * pSection = &empty;

+    const SI_CHAR * pItem = NULL;

+    const SI_CHAR * pVal = NULL;

+    const SI_CHAR * pComment = NULL;

+    bool bCopyStrings = (m_pData != NULL);

+

+    // find a file comment if it exists, this is a comment that starts at the

+    // beginning of the file and continues until the first blank line.

+    SI_Error rc = FindFileComment(pWork, bCopyStrings);

+    if (rc < 0) return rc;

+

+    // add every entry in the file to the data table. We copy the strings if

+    // we are loading data into this class when we already have stored some

+    // because we only store a single block.

+    while (FindEntry(pWork, pSection, pItem, pVal, pComment)) {

+        rc = AddEntry(pSection, pItem, pVal, pComment, bCopyStrings);

+        if (rc < 0) return rc;

+    }

+

+    // store these strings if we didn't copy them

+    if (bCopyStrings) {

+        delete[] pData;

+    }

+    else {

+        m_pData = pData;

+        m_uDataLen = uLen+1;

+    }

+

+    return SI_OK;

+}

+

+#ifdef SI_SUPPORT_IOSTREAMS

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::Load(

+    std::istream & a_istream

+    )

+{

+    std::string strData;

+    char szBuf[512];

+    do {

+        a_istream.get(szBuf, sizeof(szBuf), '\0');

+        strData.append(szBuf);

+    }

+    while (a_istream.good());

+    return Load(strData);

+}

+#endif // SI_SUPPORT_IOSTREAMS

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::FindFileComment(

+    SI_CHAR *&      a_pData,

+    bool            a_bCopyStrings

+    )

+{

+    // there can only be a single file comment

+    if (m_pFileComment) {

+        return SI_OK;

+    }

+

+    // the file comment must start at the first character of the first line

+    if (!IsComment(*a_pData)) {

+        return SI_OK;

+    }

+

+    // There is a file comment. We now need to find the end of the comment.

+    // A file comment ends at the first non-comment line. Every comment line

+    // MUST start with a comment character (no blank lines, no whitespace)

+    SI_CHAR * pLastNewLine = NULL;

+    m_pFileComment = a_pData;

+    while (IsComment(*a_pData)) {

+        while (*a_pData && !IsNewLineChar(*a_pData)) {

+            ++a_pData;

+        }

+        pLastNewLine = a_pData;

+        SkipNewLine(a_pData);

+    }

+

+    // null terminate before the last newline

+    *pLastNewLine = 0;

+

+    // copy the string if necessary

+    if (a_bCopyStrings) {

+        SI_Error rc = CopyString(m_pFileComment);

+        if (rc < 0) return rc;

+    }

+

+    return SI_OK;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::FindEntry(

+    SI_CHAR *&        a_pData,

+    const SI_CHAR *&  a_pSection,

+    const SI_CHAR *&  a_pKey,

+    const SI_CHAR *&  a_pVal,

+    const SI_CHAR *&  a_pComment

+    ) const

+{

+    a_pComment = NULL;

+

+    SI_CHAR * pLineStart = NULL;

+    SI_CHAR * pTrail = NULL;

+    while (*a_pData) {

+        pLineStart = a_pData;

+

+        // skip spaces and empty lines

+        while (*a_pData && IsSpace(*a_pData)) {

+            ++a_pData;

+        }

+        if (!*a_pData) {

+            break;

+        }

+

+        // skip processing of comment lines but keep a pointer to

+        // the start of the comment.

+        if (IsComment(*a_pData)) {

+            if (!a_pComment) {

+                a_pComment = a_pData;

+            }

+            while (*a_pData && !IsNewLineChar(*a_pData)) {

+                ++a_pData;

+            }

+            continue;

+        }

+

+        // if we have been tracking comments then we now end it in preparation

+        // for an item. The pointer pLineStart will point to the newline

+        // character at the end of the last comment line.

+        if (a_pComment) {

+            SI_ASSERT(pLineStart > a_pComment && IsNewLineChar(*pLineStart));

+            *pLineStart = 0;

+            pLineStart = NULL; // used only for comment lines

+        }

+

+        // process section names

+        if (*a_pData == '[') {

+            // skip leading spaces

+            ++a_pData;

+            while (*a_pData && IsSpace(*a_pData)) {

+                ++a_pData;

+            }

+

+            // find the end of the section name (it may contain spaces)

+            // and convert it to lowercase as necessary

+            a_pSection = a_pData;

+            while (*a_pData && *a_pData != ']' && !IsNewLineChar(*a_pData)) {

+                ++a_pData;

+            }

+

+            // if it's an invalid line, just skip it

+            if (*a_pData != ']') {

+                continue;

+            }

+

+            // remove trailing spaces from the section

+            pTrail = a_pData - 1;

+            while (pTrail >= a_pSection && IsSpace(*pTrail)) {

+                --pTrail;

+            }

+            ++pTrail;

+            *pTrail = 0;

+

+            // skip to the end of the line

+            ++a_pData;  // safe as checked that it == ']' above

+            while (*a_pData && !IsNewLineChar(*a_pData)) {

+                ++a_pData;

+            }

+

+            a_pKey = NULL;

+            a_pVal = NULL;

+            return true;

+        }

+

+        // find the end of the key name (it may contain spaces)

+        // and convert it to lowercase as necessary

+        a_pKey = a_pData;

+        while (*a_pData && *a_pData != '=' && !IsNewLineChar(*a_pData)) {

+            ++a_pData;

+        }

+

+        // if it's an invalid line, just skip it

+        if (*a_pData != '=') {

+            continue;

+        }

+

+        // empty keys are invalid

+        if (a_pKey == a_pData) {

+            while (*a_pData && !IsNewLineChar(*a_pData)) {

+                ++a_pData;

+            }

+            continue;

+        }

+

+        // remove trailing spaces from the key

+        pTrail = a_pData - 1;

+        while (pTrail >= a_pKey && IsSpace(*pTrail)) {

+            --pTrail;

+        }

+        ++pTrail;

+        *pTrail = 0;

+

+        // skip leading whitespace on the value

+        ++a_pData;  // safe as checked that it == '=' above

+        while (*a_pData && !IsNewLineChar(*a_pData) && IsSpace(*a_pData)) {

+            ++a_pData;

+        }

+

+        // find the end of the value which is the end of this line

+        a_pVal = a_pData;

+        while (*a_pData && !IsNewLineChar(*a_pData)) {

+            ++a_pData;

+        }

+

+        // remove trailing spaces from the value

+        pTrail = a_pData - 1;

+        if (*a_pData) { // prepare for the next round

+            SkipNewLine(a_pData);

+        }

+        while (pTrail >= a_pVal && IsSpace(*pTrail)) {

+            --pTrail;

+        }

+        ++pTrail;

+        *pTrail = 0;

+

+        // check for multi-line entries

+        if (m_bAllowMultiLine && IsMultiLineTag(a_pVal)) {

+            return FindMultiLine(a_pData, a_pVal);

+        }

+

+        // return the standard entry

+        return true;

+    }

+

+    return false;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::IsMultiLineTag(

+    const SI_CHAR * a_pVal

+    ) const

+{

+    // check for the "<<<" prefix for a multi-line entry

+    if (*a_pVal++ != '<') return false;

+    if (*a_pVal++ != '<') return false;

+    if (*a_pVal++ != '<') return false;

+    return true;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::IsMultiLineData(

+    const SI_CHAR * a_pData

+    ) const

+{

+    // data is multi-line if it has any of the following features:

+    //  * whitespace prefix

+    //  * embedded newlines

+    //  * whitespace suffix

+

+    // empty string

+    if (!*a_pData) {

+        return false;

+    }

+

+    // check for prefix

+    if (IsSpace(*a_pData)) {

+        return true;

+    }

+

+    // embedded newlines

+    while (*a_pData) {

+        if (IsNewLineChar(*a_pData)) {

+            return true;

+        }

+        ++a_pData;

+    }

+

+    // check for suffix

+    if (IsSpace(*--a_pData)) {

+        return true;

+    }

+

+    return false;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::IsNewLineChar(

+    SI_CHAR a_c

+    ) const

+{

+    return (a_c == '\n' || a_c == '\r');

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::FindMultiLine(

+    SI_CHAR *&          a_pData,

+    const SI_CHAR *&    a_pVal

+    ) const

+{

+    // skip the "<<<" to get the tag that will end the multiline

+    const SI_CHAR * pTagName = a_pVal + 3;

+    a_pVal = a_pData; // real value starts on next line

+

+    // find the end tag. This tag must start in column 1 and be

+    // followed by a newline. No whitespace removal is done while

+    // searching for this tag.

+    SI_CHAR *pLine;

+    SI_CHAR cRememberThis;

+    for(;;) {

+        // find the beginning and end of this line

+        while (IsNewLineChar(*a_pData)) ++a_pData;

+        pLine = a_pData;

+        while (*a_pData && !IsNewLineChar(*a_pData)) ++a_pData;

+

+        // end the line with a NULL

+        cRememberThis = *a_pData;

+        *a_pData = 0;

+

+        // see if we have found the tag

+        if (!IsLess(pLine, pTagName) && !IsLess(pTagName, pLine)) {

+            // null terminate the data before the newline of the previous line.

+            // If you want a new line at the end of the line then add an empty

+            // line before the tag.

+            --pLine;

+            if (*(pLine-1) == '\r') {

+                // handle Windows style newlines. This handles Unix newline files

+                // on Windows and Windows style newlines on Unix. \n\r

+                --pLine;

+            }

+            *pLine = 0;

+

+            if (cRememberThis) {

+                ++a_pData;

+            }

+            return true;

+        }

+

+        // otherwise put the char back and continue checking

+        if (!cRememberThis) {

+            return false;

+        }

+        *a_pData++ = cRememberThis;

+    }

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::CopyString(

+    const SI_CHAR *& a_pString

+    )

+{

+    size_t uLen = 0;

+    if (sizeof(SI_CHAR) == sizeof(char)) {

+        uLen = strlen((const char *)a_pString);

+    }

+    else if (sizeof(SI_CHAR) == sizeof(wchar_t)) {

+        uLen = wcslen((const wchar_t *)a_pString);

+    }

+    else {

+        for ( ; a_pString[uLen]; ++uLen) /*loop*/ ;

+    }

+    ++uLen; // NULL character

+    SI_CHAR * pCopy = new SI_CHAR[uLen];

+    if (!pCopy) {

+        return SI_NOMEM;

+    }

+    memcpy(pCopy, a_pString, sizeof(SI_CHAR)*uLen);

+    m_strings.push_back(pCopy);

+    a_pString = pCopy;

+    return SI_OK;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::AddEntry(

+    const SI_CHAR * a_pSection,

+    const SI_CHAR * a_pKey,

+    const SI_CHAR * a_pValue,

+    const SI_CHAR * a_pComment,

+    bool            a_bCopyStrings

+    )

+{

+    SI_Error rc;

+    bool bInserted = false;

+

+    SI_ASSERT(!a_pComment || IsComment(*a_pComment));

+

+    // if we are copying strings then make a copy of the comment now

+    // because we will need it when we add the entry.

+    if (a_bCopyStrings && a_pComment) {

+        rc = CopyString(a_pComment);

+        if (rc < 0) return rc;

+    }

+

+    // check for existence of the section first if we need string copies

+    typename TSection::iterator iSection = m_data.end();

+    if (a_bCopyStrings) {

+        iSection = m_data.find(a_pSection);

+        if (iSection == m_data.end()) {

+            // if the section doesn't exist then we need a copy as the

+            // string needs to last beyond the end of this function

+            // because we will be inserting the section next

+            rc = CopyString(a_pSection);

+            if (rc < 0) return rc;

+        }

+    }

+

+    // create the section entry

+    if (iSection == m_data.end()) {

+        Entry oKey(a_pSection, ++m_nOrder);

+        if (a_pComment && (!a_pKey || !a_pValue)) {

+            oKey.pComment = a_pComment;

+        }

+        typename TSection::value_type oEntry(oKey, TKeyVal());

+        std::pair<TSection::iterator,bool> i =

+            m_data.insert(oEntry);

+        iSection = i.first;

+        bInserted = true;

+    }

+    if (!a_pKey || !a_pValue) {

+        // section only entries are specified with pItem and pVal as NULL

+        return bInserted ? SI_INSERTED : SI_UPDATED;

+    }

+

+    // check for existence of the key

+    TKeyVal & keyval = iSection->second;

+    typename TKeyVal::iterator iKey = keyval.find(a_pKey);

+

+    // make string copies if necessary

+    if (a_bCopyStrings) {

+        if (m_bAllowMultiKey || iKey == keyval.end()) {

+            // if the key doesn't exist then we need a copy as the

+            // string needs to last beyond the end of this function

+            // because we will be inserting the key next

+            rc = CopyString(a_pKey);

+            if (rc < 0) return rc;

+        }

+

+        // we always need a copy of the value

+        rc = CopyString(a_pValue);

+        if (rc < 0) return rc;

+    }

+

+    // create the key entry

+    if (iKey == keyval.end() || m_bAllowMultiKey) {

+        Entry oKey(a_pKey, ++m_nOrder);

+        if (a_pComment) {

+            oKey.pComment = a_pComment;

+        }

+        typename TKeyVal::value_type oEntry(oKey, NULL);

+        iKey = keyval.insert(oEntry);

+        bInserted = true;

+    }

+    iKey->second = a_pValue;

+    return bInserted ? SI_INSERTED : SI_UPDATED;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+const SI_CHAR *

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetValue(

+    const SI_CHAR * a_pSection,

+    const SI_CHAR * a_pKey,

+    const SI_CHAR * a_pDefault,

+    bool *          a_pHasMultiple

+    ) const

+{

+    if (a_pHasMultiple) {

+        *a_pHasMultiple = false;

+    }

+    if (!a_pSection || !a_pKey) {

+        return a_pDefault;

+    }

+    typename TSection::const_iterator iSection = m_data.find(a_pSection);

+    if (iSection == m_data.end()) {

+        return a_pDefault;

+    }

+    typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);

+    if (iKeyVal == iSection->second.end()) {

+        return a_pDefault;

+    }

+

+    // check for multiple entries with the same key

+    if (m_bAllowMultiKey && a_pHasMultiple) {

+        typename TKeyVal::const_iterator iTemp = iKeyVal;

+        if (++iTemp != iSection->second.end()) {

+            if (!IsLess(a_pKey, iTemp->first.pItem)) {

+                *a_pHasMultiple = true;

+            }

+        }

+    }

+

+    return iKeyVal->second;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetAllValues(

+    const SI_CHAR * a_pSection,

+    const SI_CHAR * a_pKey,

+    TNamesDepend &  a_values

+    ) const

+{

+    if (!a_pSection || !a_pKey) {

+        return false;

+    }

+    typename TSection::const_iterator iSection = m_data.find(a_pSection);

+    if (iSection == m_data.end()) {

+        return false;

+    }

+    typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);

+    if (iKeyVal == iSection->second.end()) {

+        return false;

+    }

+

+    // insert all values for this key

+    a_values.push_back(iKeyVal->second);

+    if (m_bAllowMultiKey) {

+        ++iKeyVal;

+        while (iKeyVal != iSection->second.end() && !IsLess(a_pKey, iKeyVal->first.pItem)) {

+            a_values.push_back(Entry(iKeyVal->second, iKeyVal->first.nOrder));

+            ++iKeyVal;

+        }

+    }

+

+    return true;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+int

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetSectionSize(

+    const SI_CHAR * a_pSection

+    ) const

+{

+    if (!a_pSection) {

+        return -1;

+    }

+

+    typename TSection::const_iterator iSection = m_data.find(a_pSection);

+    if (iSection == m_data.end()) {

+        return -1;

+    }

+    const TKeyVal & section = iSection->second;

+

+    // if multi-key isn't permitted then the section size is

+    // the number of keys that we have.

+    if (!m_bAllowMultiKey || section.empty()) {

+        return (int) section.size();

+    }

+

+    // otherwise we need to count them

+    int nCount = 0;

+    const SI_CHAR * pLastKey = NULL;

+    typename TKeyVal::const_iterator iKeyVal = section.begin();

+    for (int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n) {

+        if (!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem)) {

+            ++nCount;

+            pLastKey = iKeyVal->first.pItem;

+        }

+    }

+    return nCount;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+const typename CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::TKeyVal *

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetSection(

+    const SI_CHAR * a_pSection

+    ) const

+{

+    if (a_pSection) {

+        typename TSection::const_iterator i = m_data.find(a_pSection);

+        if (i != m_data.end()) {

+            return &(i->second);

+        }

+    }

+    return 0;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+void

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetAllSections(

+    TNamesDepend & a_names

+    ) const

+{

+    typename TSection::const_iterator i = m_data.begin();

+    for (int n = 0; i != m_data.end(); ++i, ++n ) {

+        a_names.push_back(i->first);

+    }

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+void

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::GetAllKeys(

+    const SI_CHAR * a_pSection,

+    TNamesDepend &  a_names

+    ) const

+{

+    if (!a_pSection) {

+        return;

+    }

+

+    typename TSection::const_iterator iSection = m_data.find(a_pSection);

+    if (iSection == m_data.end()) {

+        return;

+    }

+

+    const TKeyVal & section = iSection->second;

+    const SI_CHAR * pLastKey = NULL;

+    typename TKeyVal::const_iterator iKeyVal = section.begin();

+    for (int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n ) {

+        if (!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem)) {

+            a_names.push_back(iKeyVal->first);

+            pLastKey = iKeyVal->first.pItem;

+        }

+    }

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::SaveFile(

+    const char * a_pszFile

+    )

+{

+    FILE * fp = fopen(a_pszFile, "wb");

+    if (!fp) return SI_FILE;

+    SI_Error rc = SaveFile(fp, true);

+    fclose(fp);

+    return rc;

+}

+

+#ifdef SI_HAS_WIDE_FILE

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::SaveFile(

+    const SI_WCHAR_T * a_pwszFile

+    )

+{

+#ifdef _WIN32

+    FILE * fp = _wfopen(a_pwszFile, L"wb");

+    if (!fp) return SI_FILE;

+    SI_Error rc = SaveFile(fp, true);

+    fclose(fp);

+    return rc;

+#else // SI_CONVERT_ICU

+    char szFile[256];

+    u_austrncpy(szFile, a_pwszFile, sizeof(szFile));

+    return SaveFile(szFile);

+#endif

+}

+#endif // SI_HAS_WIDE_FILE

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::SaveFile(

+    FILE *  a_pFile,

+    bool    a_bUseBOM

+    ) const

+{

+    FileWriter writer(a_pFile);

+    if (m_bStoreIsUtf8 && a_bUseBOM) {

+        writer.Write(SI_BOM_UTF8);

+    }

+    return Save(writer);

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+SI_Error

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::Save(

+    OutputWriter & a_oOutput

+    ) const

+{

+    Converter convert(m_bStoreIsUtf8);

+

+    // get all of the sections sorted in load order

+    TNamesDepend oSections;

+    GetAllSections(oSections);

+#if defined(_MSC_VER) && _MSC_VER <= 1200

+    oSections.sort();

+#else

+    oSections.sort(Entry::LoadOrder());

+#endif

+

+    // write the file comment if we have one

+    bool bNeedNewLine = false;

+    if (m_pFileComment) {

+        if (!convert.ConvertToStore(m_pFileComment)) {

+            return SI_FAIL;

+        }

+        a_oOutput.Write(convert.Data());

+        a_oOutput.Write(SI_NEWLINE_A);

+        bNeedNewLine = true;

+    }

+

+    // iterate through our sections and output the data

+    typename TNamesDepend::const_iterator iSection = oSections.begin();

+    for ( ; iSection != oSections.end(); ++iSection ) {

+        // write out the comment if there is one

+        if (iSection->pComment) {

+            if (!convert.ConvertToStore(iSection->pComment)) {

+                return SI_FAIL;

+            }

+            if (bNeedNewLine) {

+                a_oOutput.Write(SI_NEWLINE_A);

+                a_oOutput.Write(SI_NEWLINE_A);

+            }

+            a_oOutput.Write(convert.Data());

+            a_oOutput.Write(SI_NEWLINE_A);

+            bNeedNewLine = false;

+        }

+

+        if (bNeedNewLine) {

+            a_oOutput.Write(SI_NEWLINE_A);

+            a_oOutput.Write(SI_NEWLINE_A);

+            bNeedNewLine = false;

+        }

+

+        // write the section (unless there is no section name)

+        if (*iSection->pItem) {

+            if (!convert.ConvertToStore(iSection->pItem)) {

+                return SI_FAIL;

+            }

+            a_oOutput.Write("[");

+            a_oOutput.Write(convert.Data());

+            a_oOutput.Write("]");

+            a_oOutput.Write(SI_NEWLINE_A);

+        }

+

+        // get all of the keys sorted in load order

+        TNamesDepend oKeys;

+        GetAllKeys(iSection->pItem, oKeys);

+#if defined(_MSC_VER) && _MSC_VER <= 1200

+        oKeys.sort();

+#else

+        oKeys.sort(Entry::LoadOrder());

+#endif

+

+        // write all keys and values

+        typename TNamesDepend::const_iterator iKey = oKeys.begin();

+        for ( ; iKey != oKeys.end(); ++iKey) {

+            // get all values for this key

+            TNamesDepend oValues;

+            GetAllValues(iSection->pItem, iKey->pItem, oValues);

+

+            // write out the comment if there is one

+            if (iKey->pComment) {

+                if (!convert.ConvertToStore(iKey->pComment)) {

+                    return SI_FAIL;

+                }

+                a_oOutput.Write(SI_NEWLINE_A);

+                a_oOutput.Write(convert.Data());

+                a_oOutput.Write(SI_NEWLINE_A);

+            }

+

+            typename TNamesDepend::const_iterator iValue = oValues.begin();

+            for ( ; iValue != oValues.end(); ++iValue) {

+                // write the key

+                if (!convert.ConvertToStore(iKey->pItem)) {

+                    return SI_FAIL;

+                }

+                a_oOutput.Write(convert.Data());

+

+                // write the value

+                if (!convert.ConvertToStore(iValue->pItem)) {

+                    return SI_FAIL;

+                }

+                a_oOutput.Write("=");

+                if (m_bAllowMultiLine && IsMultiLineData(iValue->pItem)) {

+                    a_oOutput.Write("<<<SI-END-OF-MULTILINE-TEXT" SI_NEWLINE_A);

+                    a_oOutput.Write(convert.Data());

+                    a_oOutput.Write(SI_NEWLINE_A "SI-END-OF-MULTILINE-TEXT");

+                }

+                else {

+                    a_oOutput.Write(convert.Data());

+                }

+                a_oOutput.Write(SI_NEWLINE_A);

+            }

+        }

+

+        bNeedNewLine = true;

+    }

+

+    return SI_OK;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+bool

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::Delete(

+    const SI_CHAR * a_pSection,

+    const SI_CHAR * a_pKey,

+    bool            a_bRemoveEmpty

+    )

+{

+    if (!a_pSection) {

+        return false;

+    }

+

+    typename TSection::iterator iSection = m_data.find(a_pSection);

+    if (iSection == m_data.end()) {

+        return false;

+    }

+

+    // remove a single key if we have a keyname

+    if (a_pKey) {

+        typename TKeyVal::iterator iKeyVal = iSection->second.find(a_pKey);

+        if (iKeyVal == iSection->second.end()) {

+            return false;

+        }

+

+        // remove any copied strings and then the key

+        typename TKeyVal::iterator iDelete;

+        do {

+            iDelete = iKeyVal++;

+

+            DeleteString(iDelete->first.pItem);

+            DeleteString(iDelete->second);

+            iSection->second.erase(iDelete);

+        }

+        while (iKeyVal != iSection->second.end()

+            && !IsLess(a_pKey, iKeyVal->first.pItem));

+

+        // done now if the section is not empty or we are not pruning away

+        // the empty sections. Otherwise let it fall through into the section

+        // deletion code

+        if (!a_bRemoveEmpty || !iSection->second.empty()) {

+            return true;

+        }

+    }

+    else {

+        // delete all copied strings from this section. The actual

+        // entries will be removed when the section is removed.

+        typename TKeyVal::iterator iKeyVal = iSection->second.begin();

+        for ( ; iKeyVal != iSection->second.end(); ++iKeyVal) {

+            DeleteString(iKeyVal->first.pItem);

+            DeleteString(iKeyVal->second);

+        }

+    }

+

+    // delete the section itself

+    DeleteString(iSection->first.pItem);

+    m_data.erase(iSection);

+

+    return true;

+}

+

+template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>

+void

+CSimpleIniTempl<SI_CHAR,SI_STRLESS,SI_CONVERTER>::DeleteString(

+    const SI_CHAR * a_pString

+    )

+{

+    // strings may exist either inside the data block, or they will be

+    // individually allocated and stored in m_strings. We only physically

+    // delete those stored in m_strings.

+    if (a_pString < m_pData || a_pString >= m_pData + m_uDataLen) {

+        typename TNamesDepend::iterator i = m_strings.begin();

+        for (;i != m_strings.end(); ++i) {

+            if (a_pString == i->pItem) {

+                delete[] const_cast<SI_CHAR*>(i->pItem);

+                m_strings.erase(i);

+                break;

+            }

+        }

+    }

+}

+

+// ---------------------------------------------------------------------------

+//                              CONVERSION FUNCTIONS

+// ---------------------------------------------------------------------------

+

+// Defines the conversion classes for different libraries. Before including

+// SimpleIni.h, set the converter that you wish you use by defining one of the

+// following symbols.

+//

+//  SI_CONVERT_GENERIC      Use the Unicode reference conversion library in

+//                          the accompanying files ConvertUTF.h/c

+//  SI_CONVERT_ICU          Use the IBM ICU conversion library. Requires

+//                          ICU headers on include path and icuuc.lib

+//  SI_CONVERT_WIN32        Use the Win32 API functions for conversion.

+

+#if !defined(SI_CONVERT_GENERIC) && !defined(SI_CONVERT_WIN32) && !defined(SI_CONVERT_ICU)

+# ifdef _WIN32

+#  define SI_CONVERT_WIN32

+# else

+#  define SI_CONVERT_GENERIC

+# endif

+#endif

+

+/**

+ * Generic case-sensitive less than comparison. This class returns numerically

+ * ordered ASCII case-sensitive text for all possible sizes and types of

+ * SI_CHAR.

+ */

+template<class SI_CHAR>

+struct SI_GenericCase {

+	bool operator()(const SI_CHAR * pLeft, const SI_CHAR * pRight) const {

+        long cmp;

+        for ( ;*pLeft && *pRight; ++pLeft, ++pRight) {

+            cmp = (long) *pLeft - (long) *pRight;

+            if (cmp != 0) {

+                return cmp < 0;

+            }

+        }

+        return *pRight != 0;

+    }

+};

+

+/**

+ * Generic ASCII case-insensitive less than comparison. This class returns

+ * numerically ordered ASCII case-insensitive text for all possible sizes

+ * and types of SI_CHAR. It is not safe for MBCS text comparison where

+ * ASCII A-Z characters are used in the encoding of multi-byte characters.

+ */

+template<class SI_CHAR>

+struct SI_GenericNoCase {

+    inline SI_CHAR locase(SI_CHAR ch) const {

+        return (ch < 'A' || ch > 'Z') ? ch : (ch - 'A' + 'a');

+    }

+	bool operator()(const SI_CHAR * pLeft, const SI_CHAR * pRight) const {

+        long cmp;

+        for ( ;*pLeft && *pRight; ++pLeft, ++pRight) {

+            cmp = (long) locase(*pLeft) - (long) locase(*pRight);

+            if (cmp != 0) {

+                return cmp < 0;

+            }

+        }

+        return *pRight != 0;

+    }

+};

+

+/**

+ * Null conversion class for MBCS/UTF-8 to char (or equivalent).

+ */

+template<class SI_CHAR>

+class SI_ConvertA {

+    bool m_bStoreIsUtf8;

+protected:

+    SI_ConvertA() { }

+public:

+    SI_ConvertA(bool a_bStoreIsUtf8) : m_bStoreIsUtf8(a_bStoreIsUtf8) { }

+

+    /* copy and assignment */

+    SI_ConvertA(const SI_ConvertA & rhs) { operator=(rhs); }

+    SI_ConvertA & operator=(const SI_ConvertA & rhs) {

+        m_bStoreIsUtf8 = rhs.m_bStoreIsUtf8;

+        return *this;

+    }

+

+    /** Calculate the number of SI_CHAR required for converting the input

+     * from the storage format. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @return              Number of SI_CHAR required by the string when

+     *                      converted. If there are embedded NULL bytes in the

+     *                      input data, only the string up and not including

+     *                      the NULL byte will be converted.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen)

+    {

+        (void)a_pInputData;

+        SI_ASSERT(a_uInputDataLen != (size_t) -1);

+

+        // ASCII/MBCS/UTF-8 needs no conversion

+        return a_uInputDataLen;

+    }

+

+    /** Convert the input string from the storage format to SI_CHAR.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @param a_pOutputData Pointer to the output buffer to received the

+     *                      converted data.

+     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.

+     * @return              true if all of the input data was successfully

+     *                      converted.

+     */

+    bool ConvertFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen,

+        SI_CHAR *       a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        // ASCII/MBCS/UTF-8 needs no conversion

+        if (a_uInputDataLen > a_uOutputDataSize) {

+            return false;

+        }

+        memcpy(a_pOutputData, a_pInputData, a_uInputDataLen);

+        return true;

+    }

+

+    /** Calculate the number of char required by the storage format of this

+     * data. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated string to calculate the number of

+     *                      bytes required to be converted to storage format.

+     * @return              Number of bytes required by the string when

+     *                      converted to storage format. This size always

+     *                      includes space for the terminating NULL character.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeToStore(

+        const SI_CHAR * a_pInputData)

+    {

+        // ASCII/MBCS/UTF-8 needs no conversion

+        return strlen((const char *)a_pInputData) + 1;

+    }

+

+    /** Convert the input string to the storage format of this data.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated source string to convert. All of

+     *                      the data will be converted including the

+     *                      terminating NULL character.

+     * @param a_pOutputData Pointer to the buffer to receive the converted

+     *                      string.

+     * @param a_uOutputDataSize Size of the output buffer in char.

+     * @return              true if all of the input data, including the

+     *                      terminating NULL character was successfully

+     *                      converted.

+     */

+    bool ConvertToStore(

+        const SI_CHAR * a_pInputData,

+        char *          a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        // calc input string length (SI_CHAR type and size independent)

+        size_t uInputLen = strlen((const char *)a_pInputData) + 1;

+        if (uInputLen > a_uOutputDataSize) {

+            return false;

+        }

+

+        // ascii/UTF-8 needs no conversion

+        memcpy(a_pOutputData, a_pInputData, uInputLen);

+        return true;

+    }

+};

+

+

+// ---------------------------------------------------------------------------

+//                              SI_CONVERT_GENERIC

+// ---------------------------------------------------------------------------

+#ifdef SI_CONVERT_GENERIC

+

+#define SI_Case     SI_GenericCase

+#define SI_NoCase   SI_GenericNoCase

+

+#include <wchar.h>

+#include "ConvertUTF.h"

+

+/**

+ * Converts UTF-8 to a wchar_t (or equivalent) using the Unicode reference

+ * library functions. This can be used on all platforms.

+ */

+template<class SI_CHAR>

+class SI_ConvertW {

+    bool m_bStoreIsUtf8;

+protected:

+    SI_ConvertW() { }

+public:

+    SI_ConvertW(bool a_bStoreIsUtf8) : m_bStoreIsUtf8(a_bStoreIsUtf8) { }

+

+    /* copy and assignment */

+    SI_ConvertW(const SI_ConvertW & rhs) { operator=(rhs); }

+    SI_ConvertW & operator=(const SI_ConvertW & rhs) {

+        m_bStoreIsUtf8 = rhs.m_bStoreIsUtf8;

+        return *this;

+    }

+

+    /** Calculate the number of SI_CHAR required for converting the input

+     * from the storage format. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @return              Number of SI_CHAR required by the string when

+     *                      converted. If there are embedded NULL bytes in the

+     *                      input data, only the string up and not including

+     *                      the NULL byte will be converted.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen)

+    {

+        SI_ASSERT(a_uInputDataLen != (size_t) -1);

+

+        if (m_bStoreIsUtf8) {

+            // worst case scenario for UTF-8 to wchar_t is 1 char -> 1 wchar_t

+            // so we just return the same number of characters required as for

+            // the source text.

+            return a_uInputDataLen;

+        }

+        else {

+            return mbstowcs(NULL, a_pInputData, a_uInputDataLen);

+        }

+    }

+

+    /** Convert the input string from the storage format to SI_CHAR.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @param a_pOutputData Pointer to the output buffer to received the

+     *                      converted data.

+     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.

+     * @return              true if all of the input data was successfully

+     *                      converted.

+     */

+    bool ConvertFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen,

+        SI_CHAR *       a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        if (m_bStoreIsUtf8) {

+            // This uses the Unicode reference implementation to do the

+            // conversion from UTF-8 to wchar_t. The required files are

+            // ConvertUTF.h and ConvertUTF.c which should be included in

+            // the distribution but are publically available from unicode.org

+            // at http://www.unicode.org/Public/PROGRAMS/CVTUTF/

+            ConversionResult retval;

+            const UTF8 * pUtf8 = (const UTF8 *) a_pInputData;

+            if (sizeof(wchar_t) == sizeof(UTF32)) {

+                UTF32 * pUtf32 = (UTF32 *) a_pOutputData;

+                retval = ConvertUTF8toUTF32(

+                    &pUtf8, pUtf8 + a_uInputDataLen,

+                    &pUtf32, pUtf32 + a_uOutputDataSize,

+                    lenientConversion);

+            }

+            else if (sizeof(wchar_t) == sizeof(UTF16)) {

+                UTF16 * pUtf16 = (UTF16 *) a_pOutputData;

+                retval = ConvertUTF8toUTF16(

+                    &pUtf8, pUtf8 + a_uInputDataLen,

+                    &pUtf16, pUtf16 + a_uOutputDataSize,

+                    lenientConversion);

+            }

+            return retval == conversionOK;

+        }

+        else {

+            size_t retval = mbstowcs(a_pOutputData,

+                a_pInputData, a_uOutputDataSize);

+            return retval != (size_t)(-1);

+        }

+    }

+

+    /** Calculate the number of char required by the storage format of this

+     * data. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated string to calculate the number of

+     *                      bytes required to be converted to storage format.

+     * @return              Number of bytes required by the string when

+     *                      converted to storage format. This size always

+     *                      includes space for the terminating NULL character.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeToStore(

+        const SI_CHAR * a_pInputData)

+    {

+        if (m_bStoreIsUtf8) {

+            // worst case scenario for wchar_t to UTF-8 is 1 wchar_t -> 6 char

+            size_t uLen = 0;

+            while (a_pInputData[uLen]) {

+                ++uLen;

+            }

+            return (6 * uLen) + 1;

+        }

+        else {

+            size_t uLen = wcstombs(NULL, a_pInputData, 0);

+            if (uLen == (size_t)(-1)) {

+                return uLen;

+            }

+            return uLen + 1; // include NULL terminator

+        }

+    }

+

+    /** Convert the input string to the storage format of this data.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated source string to convert. All of

+     *                      the data will be converted including the

+     *                      terminating NULL character.

+     * @param a_pOutputData Pointer to the buffer to receive the converted

+     *                      string.

+     * @param a_uOutputDataSize Size of the output buffer in char.

+     * @return              true if all of the input data, including the

+     *                      terminating NULL character was successfully

+     *                      converted.

+     */

+    bool ConvertToStore(

+        const SI_CHAR * a_pInputData,

+        char *          a_pOutputData,

+        size_t          a_uOutputDataSize

+        )

+    {

+        if (m_bStoreIsUtf8) {

+            // calc input string length (SI_CHAR type and size independent)

+            size_t uInputLen = 0;

+            while (a_pInputData[uInputLen]) {

+                ++uInputLen;

+            }

+            ++uInputLen; // include the NULL char

+

+            // This uses the Unicode reference implementation to do the

+            // conversion from wchar_t to UTF-8. The required files are

+            // ConvertUTF.h and ConvertUTF.c which should be included in

+            // the distribution but are publically available from unicode.org

+            // at http://www.unicode.org/Public/PROGRAMS/CVTUTF/

+            ConversionResult retval;

+            UTF8 * pUtf8 = (UTF8 *) a_pOutputData;

+            if (sizeof(wchar_t) == sizeof(UTF32)) {

+                const UTF32 * pUtf32 = (const UTF32 *) a_pInputData;

+                retval = ConvertUTF32toUTF8(

+                    &pUtf32, pUtf32 + uInputLen + 1,

+                    &pUtf8, pUtf8 + a_uOutputDataSize,

+                    lenientConversion);

+            }

+            else if (sizeof(wchar_t) == sizeof(UTF16)) {

+                const UTF16 * pUtf16 = (const UTF16 *) a_pInputData;

+                retval = ConvertUTF16toUTF8(

+                    &pUtf16, pUtf16 + uInputLen + 1,

+                    &pUtf8, pUtf8 + a_uOutputDataSize,

+                    lenientConversion);

+            }

+            return retval == conversionOK;

+        }

+        else {

+            size_t retval = wcstombs(a_pOutputData,

+                a_pInputData, a_uOutputDataSize);

+            return retval != (size_t) -1;

+        }

+    }

+};

+

+#endif // SI_CONVERT_GENERIC

+

+

+// ---------------------------------------------------------------------------

+//                              SI_CONVERT_ICU

+// ---------------------------------------------------------------------------

+#ifdef SI_CONVERT_ICU

+

+#define SI_Case     SI_GenericCase

+#define SI_NoCase   SI_GenericNoCase

+

+#include <unicode/ucnv.h>

+

+/**

+ * Converts MBCS/UTF-8 to UChar using ICU. This can be used on all platforms.

+ */

+template<class SI_CHAR>

+class SI_ConvertW {

+    const char * m_pEncoding;

+    UConverter * m_pConverter;

+protected:

+    SI_ConvertW() : m_pEncoding(NULL), m_pConverter(NULL) { }

+public:

+    SI_ConvertW(bool a_bStoreIsUtf8) : m_pConverter(NULL) {

+        m_pEncoding = a_bStoreIsUtf8 ? "UTF-8" : NULL;

+    }

+

+    /* copy and assignment */

+    SI_ConvertW(const SI_ConvertW & rhs) { operator=(rhs); }

+    SI_ConvertW & operator=(const SI_ConvertW & rhs) {

+        m_pEncoding = rhs.m_pEncoding;

+        m_pConverter = NULL;

+        return *this;

+    }

+    ~SI_ConvertW() { if (m_pConverter) ucnv_close(m_pConverter); }

+

+    /** Calculate the number of UChar required for converting the input

+     * from the storage format. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to UChar.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @return              Number of UChar required by the string when

+     *                      converted. If there are embedded NULL bytes in the

+     *                      input data, only the string up and not including

+     *                      the NULL byte will be converted.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen)

+    {

+        SI_ASSERT(a_uInputDataLen != (size_t) -1);

+

+        UErrorCode nError;

+

+        if (!m_pConverter) {

+            nError = U_ZERO_ERROR;

+            m_pConverter = ucnv_open(m_pEncoding, &nError);

+            if (U_FAILURE(nError)) {

+                return (size_t) -1;

+            }

+        }

+

+        nError = U_ZERO_ERROR;

+        ucnv_resetToUnicode(m_pConverter);

+        int32_t nLen = ucnv_toUChars(m_pConverter, NULL, 0,

+            a_pInputData, (int32_t) a_uInputDataLen, &nError);

+        if (nError != U_BUFFER_OVERFLOW_ERROR) {

+            return (size_t) -1;

+        }

+

+        return (size_t) nLen;

+    }

+

+    /** Convert the input string from the storage format to UChar.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to UChar.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @param a_pOutputData Pointer to the output buffer to received the

+     *                      converted data.

+     * @param a_uOutputDataSize Size of the output buffer in UChar.

+     * @return              true if all of the input data was successfully

+     *                      converted.

+     */

+    bool ConvertFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen,

+        UChar *         a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        UErrorCode nError;

+

+        if (!m_pConverter) {

+            nError = U_ZERO_ERROR;

+            m_pConverter = ucnv_open(m_pEncoding, &nError);

+            if (U_FAILURE(nError)) {

+                return false;

+            }

+        }

+

+        nError = U_ZERO_ERROR;

+        ucnv_resetToUnicode(m_pConverter);

+        ucnv_toUChars(m_pConverter,

+            a_pOutputData, (int32_t) a_uOutputDataSize,

+            a_pInputData, (int32_t) a_uInputDataLen, &nError);

+        if (U_FAILURE(nError)) {

+            return false;

+        }

+

+        return true;

+    }

+

+    /** Calculate the number of char required by the storage format of this

+     * data. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated string to calculate the number of

+     *                      bytes required to be converted to storage format.

+     * @return              Number of bytes required by the string when

+     *                      converted to storage format. This size always

+     *                      includes space for the terminating NULL character.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeToStore(

+        const UChar * a_pInputData)

+    {

+        UErrorCode nError;

+

+        if (!m_pConverter) {

+            nError = U_ZERO_ERROR;

+            m_pConverter = ucnv_open(m_pEncoding, &nError);

+            if (U_FAILURE(nError)) {

+                return (size_t) -1;

+            }

+        }

+

+        nError = U_ZERO_ERROR;

+        ucnv_resetFromUnicode(m_pConverter);

+        int32_t nLen = ucnv_fromUChars(m_pConverter, NULL, 0,

+            a_pInputData, -1, &nError);

+        if (nError != U_BUFFER_OVERFLOW_ERROR) {

+            return (size_t) -1;

+        }

+

+        return (size_t) nLen + 1;

+    }

+

+    /** Convert the input string to the storage format of this data.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated source string to convert. All of

+     *                      the data will be converted including the

+     *                      terminating NULL character.

+     * @param a_pOutputData Pointer to the buffer to receive the converted

+     *                      string.

+     * @param a_pOutputDataSize Size of the output buffer in char.

+     * @return              true if all of the input data, including the

+     *                      terminating NULL character was successfully

+     *                      converted.

+     */

+    bool ConvertToStore(

+        const UChar *   a_pInputData,

+        char *          a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        UErrorCode nError;

+

+        if (!m_pConverter) {

+            nError = U_ZERO_ERROR;

+            m_pConverter = ucnv_open(m_pEncoding, &nError);

+            if (U_FAILURE(nError)) {

+                return false;

+            }

+        }

+

+        nError = U_ZERO_ERROR;

+        ucnv_resetFromUnicode(m_pConverter);

+        ucnv_fromUChars(m_pConverter,

+            a_pOutputData, (int32_t) a_uOutputDataSize,

+            a_pInputData, -1, &nError);

+        if (U_FAILURE(nError)) {

+            return false;

+        }

+

+        return true;

+    }

+};

+

+#endif // SI_CONVERT_ICU

+

+

+// ---------------------------------------------------------------------------

+//                              SI_CONVERT_WIN32

+// ---------------------------------------------------------------------------

+#ifdef SI_CONVERT_WIN32

+

+#define SI_Case     SI_GenericCase

+

+// Windows CE doesn't have errno or MBCS libraries

+#ifdef _WIN32_WCE

+# ifndef SI_NO_MBCS

+#  define SI_NO_MBCS

+# endif

+#endif

+

+#include <windows.h>

+#ifdef SI_NO_MBCS

+# define SI_NoCase   SI_GenericNoCase

+#else // !SI_NO_MBCS

+/**

+ * Case-insensitive comparison class using Win32 MBCS functions. This class

+ * returns a case-insensitive semi-collation order for MBCS text. It may not

+ * be safe for UTF-8 text returned in char format as we don't know what

+ * characters will be folded by the function! Therefore, if you are using

+ * SI_CHAR == char and SetUnicode(true), then you need to use the generic

+ * SI_NoCase class instead.

+ */

+#include <mbstring.h>

+template<class SI_CHAR>

+struct SI_NoCase {

+	bool operator()(const SI_CHAR * pLeft, const SI_CHAR * pRight) const {

+        if (sizeof(SI_CHAR) == sizeof(char)) {

+            return _mbsicmp((const unsigned char *)pLeft,

+                (const unsigned char *)pRight) < 0;

+        }

+        if (sizeof(SI_CHAR) == sizeof(wchar_t)) {

+            return wcsicmp((const wchar_t *)pLeft,

+                (const wchar_t *)pRight) < 0;

+        }

+        return SI_GenericNoCase<SI_CHAR>()(pLeft, pRight);

+    }

+};

+#endif // SI_NO_MBCS

+

+/**

+ * Converts MBCS and UTF-8 to a wchar_t (or equivalent) on Windows. This uses

+ * only the Win32 functions and doesn't require the external Unicode UTF-8

+ * conversion library. It will not work on Windows 95 without using Microsoft

+ * Layer for Unicode in your application.

+ */

+template<class SI_CHAR>

+class SI_ConvertW {

+    UINT m_uCodePage;

+protected:

+    SI_ConvertW() { }

+public:

+    SI_ConvertW(bool a_bStoreIsUtf8) {

+        m_uCodePage = a_bStoreIsUtf8 ? CP_UTF8 : CP_ACP;

+    }

+

+    /* copy and assignment */

+    SI_ConvertW(const SI_ConvertW & rhs) { operator=(rhs); }

+    SI_ConvertW & operator=(const SI_ConvertW & rhs) {

+        m_uCodePage = rhs.m_uCodePage;

+        return *this;

+    }

+

+    /** Calculate the number of SI_CHAR required for converting the input

+     * from the storage format. The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @return              Number of SI_CHAR required by the string when

+     *                      converted. If there are embedded NULL bytes in the

+     *                      input data, only the string up and not including

+     *                      the NULL byte will be converted.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen)

+    {

+        SI_ASSERT(a_uInputDataLen != (size_t) -1);

+

+        int retval = MultiByteToWideChar(

+            m_uCodePage, 0,

+            a_pInputData, (int) a_uInputDataLen,

+            0, 0);

+        return (size_t)(retval > 0 ? retval : -1);

+    }

+

+    /** Convert the input string from the storage format to SI_CHAR.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.

+     * @param a_uInputDataLen Length of storage format data in bytes. This

+     *                      must be the actual length of the data, including

+     *                      NULL byte if NULL terminated string is required.

+     * @param a_pOutputData Pointer to the output buffer to received the

+     *                      converted data.

+     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.

+     * @return              true if all of the input data was successfully

+     *                      converted.

+     */

+    bool ConvertFromStore(

+        const char *    a_pInputData,

+        size_t          a_uInputDataLen,

+        SI_CHAR *       a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        int nSize = MultiByteToWideChar(

+            m_uCodePage, 0,

+            a_pInputData, (int) a_uInputDataLen,

+            (wchar_t *) a_pOutputData, (int) a_uOutputDataSize);

+        return (nSize > 0);

+    }

+

+    /** Calculate the number of char required by the storage format of this

+     * data. The storage format is always UTF-8.

+     *

+     * @param a_pInputData  NULL terminated string to calculate the number of

+     *                      bytes required to be converted to storage format.

+     * @return              Number of bytes required by the string when

+     *                      converted to storage format. This size always

+     *                      includes space for the terminating NULL character.

+     * @return              -1 cast to size_t on a conversion error.

+     */

+    size_t SizeToStore(

+        const SI_CHAR * a_pInputData)

+    {

+        int retval = WideCharToMultiByte(

+            m_uCodePage, 0,

+            (const wchar_t *) a_pInputData, -1,

+            0, 0, 0, 0);

+        return (size_t) (retval > 0 ? retval : -1);

+    }

+

+    /** Convert the input string to the storage format of this data.

+     * The storage format is always UTF-8 or MBCS.

+     *

+     * @param a_pInputData  NULL terminated source string to convert. All of

+     *                      the data will be converted including the

+     *                      terminating NULL character.

+     * @param a_pOutputData Pointer to the buffer to receive the converted

+     *                      string.

+     * @param a_pOutputDataSize Size of the output buffer in char.

+     * @return              true if all of the input data, including the

+     *                      terminating NULL character was successfully

+     *                      converted.

+     */

+    bool ConvertToStore(

+        const SI_CHAR * a_pInputData,

+        char *          a_pOutputData,

+        size_t          a_uOutputDataSize)

+    {

+        int retval = WideCharToMultiByte(

+            m_uCodePage, 0,

+            (const wchar_t *) a_pInputData, -1,

+            a_pOutputData, (int) a_uOutputDataSize, 0, 0);

+        return retval > 0;

+    }

+};

+

+#endif // SI_CONVERT_WIN32

+

+

+// ---------------------------------------------------------------------------

+//                                  TYPE DEFINITIONS

+// ---------------------------------------------------------------------------

+

+typedef CSimpleIniTempl<char,

+    SI_NoCase<char>,SI_ConvertA<char> >                 CSimpleIniA;

+typedef CSimpleIniTempl<char,

+    SI_Case<char>,SI_ConvertA<char> >                   CSimpleIniCaseA;

+

+#if defined(SI_CONVERT_ICU)

+typedef CSimpleIniTempl<UChar,

+    SI_NoCase<UChar>,SI_ConvertW<UChar> >               CSimpleIniW;

+typedef CSimpleIniTempl<UChar,

+    SI_Case<UChar>,SI_ConvertW<UChar> >                 CSimpleIniCaseW;

+#else

+typedef CSimpleIniTempl<wchar_t,

+    SI_NoCase<wchar_t>,SI_ConvertW<wchar_t> >           CSimpleIniW;

+typedef CSimpleIniTempl<wchar_t,

+    SI_Case<wchar_t>,SI_ConvertW<wchar_t> >             CSimpleIniCaseW;

+#endif

+

+#ifdef _UNICODE

+# define CSimpleIni      CSimpleIniW

+# define CSimpleIniCase  CSimpleIniCaseW

+# define SI_NEWLINE      SI_NEWLINE_W

+#else // !_UNICODE

+# define CSimpleIni      CSimpleIniA

+# define CSimpleIniCase  CSimpleIniCaseA

+# define SI_NEWLINE      SI_NEWLINE_A

+#endif // _UNICODE

+

+#endif // INCLUDED_SimpleIni_h

+

diff --git a/SimpleIni.sln b/SimpleIni.sln
new file mode 100644
index 0000000..c958981
--- /dev/null
+++ b/SimpleIni.sln
@@ -0,0 +1,27 @@
+Microsoft Visual Studio Solution File, Format Version 8.00

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimpleIni", "SimpleIni.vcproj", "{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}"

+	ProjectSection(ProjectDependencies) = postProject

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfiguration) = preSolution

+		Debug = Debug

+		Debug Unicode = Debug Unicode

+		Release = Release

+		Release Unicode = Release Unicode

+	EndGlobalSection

+	GlobalSection(ProjectConfiguration) = postSolution

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Debug.ActiveCfg = Debug|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Debug.Build.0 = Debug|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Debug Unicode.ActiveCfg = Debug Unicode|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Debug Unicode.Build.0 = Debug Unicode|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Release.ActiveCfg = Release|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Release.Build.0 = Release|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Release Unicode.ActiveCfg = Release Unicode|Win32

+		{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}.Release Unicode.Build.0 = Release Unicode|Win32

+	EndGlobalSection

+	GlobalSection(ExtensibilityGlobals) = postSolution

+	EndGlobalSection

+	GlobalSection(ExtensibilityAddIns) = postSolution

+	EndGlobalSection

+EndGlobal

diff --git a/SimpleIni.vcproj b/SimpleIni.vcproj
new file mode 100644
index 0000000..c94042d
--- /dev/null
+++ b/SimpleIni.vcproj
@@ -0,0 +1,293 @@
+<?xml version="1.0" encoding="shift_jis"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="SimpleIni"

+	ProjectGUID="{C23240A6-AA9D-4827-AF06-C98E97CA6DFB}"

+	RootNamespace="SimpleIni"

+	Keyword="Win32Proj">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory="Debug"

+			IntermediateDirectory="Debug"

+			ConfigurationType="1"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+				MinimalRebuild="TRUE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="5"

+				UsePrecompiledHeader="0"

+				WarningLevel="4"

+				Detect64BitPortabilityProblems="TRUE"

+				DebugInformationFormat="4"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile="$(OutDir)/testsi.exe"

+				LinkIncremental="2"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile="$(OutDir)/SimpleIni.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory="Release"

+			IntermediateDirectory="Release"

+			ConfigurationType="1"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"

+				RuntimeLibrary="4"

+				UsePrecompiledHeader="0"

+				WarningLevel="4"

+				Detect64BitPortabilityProblems="TRUE"

+				DebugInformationFormat="3"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile="$(OutDir)/testsi.exe"

+				LinkIncremental="1"

+				GenerateDebugInformation="TRUE"

+				SubSystem="1"

+				OptimizeReferences="2"

+				EnableCOMDATFolding="2"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Debug Unicode|Win32"

+			OutputDirectory="$(ConfigurationName)"

+			IntermediateDirectory="$(ConfigurationName)"

+			ConfigurationType="1"

+			CharacterSet="1">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+				MinimalRebuild="TRUE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="5"

+				UsePrecompiledHeader="0"

+				WarningLevel="4"

+				Detect64BitPortabilityProblems="TRUE"

+				DebugInformationFormat="4"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="icuuc.lib"

+				OutputFile="$(OutDir)/testsi.exe"

+				LinkIncremental="2"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile="$(OutDir)/SimpleIni.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release Unicode|Win32"

+			OutputDirectory="$(ConfigurationName)"

+			IntermediateDirectory="$(ConfigurationName)"

+			ConfigurationType="1"

+			CharacterSet="1">

+			<Tool

+				Name="VCCLCompilerTool"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"

+				RuntimeLibrary="4"

+				UsePrecompiledHeader="0"

+				WarningLevel="4"

+				Detect64BitPortabilityProblems="TRUE"

+				DebugInformationFormat="3"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="icuuc.lib"

+				OutputFile="$(OutDir)/testsi.exe"

+				LinkIncremental="1"

+				GenerateDebugInformation="TRUE"

+				SubSystem="1"

+				OptimizeReferences="2"

+				EnableCOMDATFolding="2"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<Filter

+			Name="Source Files"

+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"

+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">

+			<File

+				RelativePath=".\snippets.cpp">

+			</File>

+			<File

+				RelativePath=".\test1.cpp">

+			</File>

+			<File

+				RelativePath=".\testsi.cpp">

+			</File>

+		</Filter>

+		<Filter

+			Name="Library Files"

+			Filter="h;hpp;hxx;hm;inl;inc;xsd"

+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">

+			<File

+				RelativePath=".\SimpleIni.h">

+			</File>

+		</Filter>

+		<Filter

+			Name="Resource Files"

+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"

+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">

+			<File

+				RelativePath=".\Makefile">

+			</File>

+			<File

+				RelativePath=".\testsi-EUCJP.ini">

+			</File>

+			<File

+				RelativePath=".\testsi-SJIS.ini">

+			</File>

+			<File

+				RelativePath=".\testsi-UTF8.ini">

+			</File>

+		</Filter>

+		<Filter

+			Name="Conversion Files"

+			Filter="">

+			<File

+				RelativePath=".\ConvertUTF.c">

+			</File>

+			<File

+				RelativePath=".\ConvertUTF.h">

+			</File>

+		</Filter>

+		<Filter

+			Name="Documentation"

+			Filter="">

+			<File

+				RelativePath=".\simpleini.doxy">

+				<FileConfiguration

+					Name="Debug|Win32">

+					<Tool

+						Name="VCCustomBuildTool"

+						CommandLine="if not exist &quot;C:\Program Files\doxygen\bin\doxygen.exe&quot; goto done

+

+echo Generating documentation...

+&quot;C:\Program Files\doxygen\bin\doxygen.exe&quot; $(InputDir)simpleini.doxy

+

+:done

+"

+						Outputs="d:\src\simpleini-doc\html\index.html"/>

+				</FileConfiguration>

+			</File>

+		</Filter>

+		<Filter

+			Name="Tests"

+			Filter="">

+			<File

+				RelativePath=".\test1-expected.ini">

+			</File>

+			<File

+				RelativePath=".\test1-input.ini">

+			</File>

+			<File

+				RelativePath=".\test1-output.ini">

+			</File>

+		</Filter>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/simpleini.doxy b/simpleini.doxy
new file mode 100644
index 0000000..943f9ae
--- /dev/null
+++ b/simpleini.doxy
@@ -0,0 +1,235 @@
+# Doxyfile 1.4.7
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = SimpleINI
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = D:/src/simpleini-doc
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = YES
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = "D:/src/simpleini/"
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+BUILTIN_STL_SUPPORT    = NO
+DISTRIBUTE_GROUP_DOC   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = NO
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_BY_SCOPE_NAME     = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_DIRECTORIES       = NO
+FILE_VERSION_FILTER    = 
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = YES
+WARN_FORMAT            = "$file($line) : $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = D:/src/simpleini/SimpleIni.h
+FILE_PATTERNS          = *.h
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+REFERENCES_LINK_SOURCE = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = SI_HAS_WIDE_FILE SI_SUPPORT_IOSTREAMS
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 1000
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
diff --git a/simpleini.dsp b/simpleini.dsp
new file mode 100644
index 0000000..97c386a
--- /dev/null
+++ b/simpleini.dsp
@@ -0,0 +1,178 @@
+# Microsoft Developer Studio Project File - Name="simpleini" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=simpleini - Win32 Debug Unicode

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "simpleini.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "simpleini.mak" CFG="simpleini - Win32 Debug Unicode"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "simpleini - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "simpleini - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE "simpleini - Win32 Debug Unicode" (based on "Win32 (x86) Console Application")

+!MESSAGE "simpleini - Win32 Release Unicode" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "simpleini - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0xc09 /d "NDEBUG"

+# ADD RSC /l 0xc09 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"Release/testsi.exe"

+

+!ELSEIF  "$(CFG)" == "simpleini - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "simpleini___Win32_Debug"

+# PROP BASE Intermediate_Dir "simpleini___Win32_Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c

+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c

+# SUBTRACT CPP /Fr /YX

+# ADD BASE RSC /l 0xc09 /d "_DEBUG"

+# ADD RSC /l 0xc09 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug/testsi.exe" /pdbtype:sept

+

+!ELSEIF  "$(CFG)" == "simpleini - Win32 Debug Unicode"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug Unicode"

+# PROP BASE Intermediate_Dir "Debug Unicode"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug Unicode"

+# PROP Intermediate_Dir "Debug Unicode"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c

+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /D "SI_USE_GENERIC_CONVERSION" /FD /GZ /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0xc09 /d "_DEBUG"

+# ADD RSC /l 0xc09 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug Unicode/testsi.exe" /pdbtype:sept

+

+!ELSEIF  "$(CFG)" == "simpleini - Win32 Release Unicode"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release Unicode"

+# PROP BASE Intermediate_Dir "Release Unicode"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release Unicode"

+# PROP Intermediate_Dir "Release Unicode"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /D "SI_USE_GENERIC_CONVERSION" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0xc09 /d "NDEBUG"

+# ADD RSC /l 0xc09 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"Release Unicode/testsi.exe"

+

+!ENDIF 

+

+# Begin Target

+

+# Name "simpleini - Win32 Release"

+# Name "simpleini - Win32 Debug"

+# Name "simpleini - Win32 Debug Unicode"

+# Name "simpleini - Win32 Release Unicode"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=.\snippets.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\test1.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\testsi.cpp

+# End Source File

+# End Group

+# Begin Group "Library Files"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=.\SimpleIni.h

+# End Source File

+# End Group

+# Begin Group "Generic Files"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=.\ConvertUTF.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\ConvertUTF.h

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/simpleini.dsw b/simpleini.dsw
new file mode 100644
index 0000000..2d593ed
--- /dev/null
+++ b/simpleini.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00

+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

+

+###############################################################################

+

+Project: "simpleini"=.\simpleini.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Global:

+

+Package=<5>

+{{{

+}}}

+

+Package=<3>

+{{{

+}}}

+

+###############################################################################

+

diff --git a/snippets.cpp b/snippets.cpp
new file mode 100644
index 0000000..74f4852
--- /dev/null
+++ b/snippets.cpp
@@ -0,0 +1,123 @@
+// File:    snippets.cpp
+// Library: SimpleIni
+// Author:  Brodie Thiesfield <code@jellycan.com>
+// Source:  http://code.jellycan.com/simpleini/
+//
+// Snippets that are used on the website
+
+#ifdef _WIN32

+# pragma warning(disable: 4786)

+#endif

+

+#ifndef _WIN32

+# include <unistd.h>

+#endif

+#include <fstream>

+

+#define SI_SUPPORT_IOSTREAMS

+#include "SimpleIni.h"
+

+bool 

+snippets(

+    const char *    a_pszFile,
+    bool            a_bIsUtf8,
+    bool            a_bUseMultiKey,
+    bool            a_bUseMultiLine
+    )

+{

+    // LOADING DATA

+

+    // load from a data file

+    CSimpleIniA ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);

+    SI_Error rc = ini.LoadFile(a_pszFile);

+    if (rc < 0) return false;

+

+    // load from a string

+    std::string strData;

+    rc = ini.Load(strData.c_str(), strData.size());

+    if (rc < 0) return false;

+

+    // GETTING SECTIONS AND KEYS

+

+    // get all sections
+    CSimpleIniA::TNamesDepend sections;

+    ini.GetAllSections(sections);

+

+    // get all keys in a section
+    CSimpleIniA::TNamesDepend keys;

+    ini.GetAllKeys("section-name", keys);

+

+    // GETTING VALUES

+

+    // get the value of a key

+    const char * pszValue = ini.GetValue("section-name", 
+        "key-name", NULL /*default*/);
+
+    // get the value of a key which may have multiple 

+    // values. If bHasMultipleValues is true, then just 

+    // one value has been returned

+    bool bHasMultipleValues;

+    pszValue = ini.GetValue("section-name", "key-name", 
+        NULL /*default*/, &bHasMultipleValues);
+
+    // get all values of a key with multiple values
+    CSimpleIniA::TNamesDepend values;

+    ini.GetAllValues("section-name", "key-name", values);

+

+    // sort the values into the original load order 
+#if defined(_MSC_VER) && _MSC_VER <= 1200

+    /** STL of VC6 doesn't allow me to specify my own comparator for list::sort() */

+    values.sort();

+#else

+    values.sort(CSimpleIniA::Entry::LoadOrder());

+#endif

+
+    // output all of the items
+    CSimpleIniA::TNamesDepend::const_iterator i;

+    for (i = values.begin(); i != values.end(); ++i) { 

+        printf("key-name = '%s'\n", i->pItem);

+    }

+

+    // MODIFYING DATA

+

+    // adding a new section

+    rc = ini.SetValue("new-section", NULL, NULL);

+    if (rc < 0) return false;

+    printf("section: %s\n", rc == SI_INSERTED ? 

+        "inserted" : "updated");

+

+    // adding a new key ("new-section" will be added 

+    // automatically if it doesn't already exist.

+    rc = ini.SetValue("new-section", "new-key", "value");

+    if (rc < 0) return false;

+    printf("key: %s\n", rc == SI_INSERTED ? 

+        "inserted" : "updated");

+

+    // changing the value of a key

+    rc = ini.SetValue("section", "key", "updated-value");

+    if (rc < 0) return false;

+    printf("key: %s\n", rc == SI_INSERTED ? 

+        "inserted" : "updated");

+

+    // DELETING DATA

+

+    // deleting a key from a section. Optionally the entire

+    // section may be deleted if it is now empty.

+    ini.Delete("section-name", "key-name", 

+        true /*delete the section if empty*/);

+

+    // deleting an entire section and all keys in it

+    ini.Delete("section-name", NULL);

+
+    // SAVING DATA
+
+    // save the data to a string

+    rc = ini.Save(strData);

+    if (rc < 0) return false;
+

+    // save the data back to the file

+    rc = ini.SaveFile(a_pszFile);

+    if (rc < 0) return false;
+
+    return true;
+}
diff --git a/test1-expected.ini b/test1-expected.ini
new file mode 100644
index 0000000..5b4645a
--- /dev/null
+++ b/test1-expected.ini
@@ -0,0 +1,65 @@
+; testsi-UTF8-std.ini : standard UTF-8 test file for SimpleIni automated testing

+;

+; The number after a section or key is the order that it is defined in this file

+; to make it easier to see if it has been written out correctly. This file should

+; be loaded with Unicode / MultiKey / MultiLine turned on.

+

+

+

+; Key with no section

+lonely-key=nosection

+another=nosection either

+

+

+; This is a section of keys showing the word Japanese in different syllabies.

+[ordered-1]

+a-1=blah

+

+; this is in kanji

+japanese-2=日本語

+

+; this is in hiragana

+japanese-3=にほんご

+

+; this is in katakana

+japanese-4=ニホンゴ

+

+; this is in romaji

+japanese-5=nihongo

+

+; kanji as the key

+日本語-6=japanese

+

+

+[multi-2]

+

+; value a

+test=a

+test=b

+test=c

+test=d

+

+

+[multiline-3]

+

+; This is obviously a multi-line entry

+multiline-1=<<<SI-END-OF-MULTILINE-TEXT

+

+This is a multi-line comment. It

+will continue until we have the word MULTI

+on a line by itself.

+

+日本語も。

+

+SI-END-OF-MULTILINE-TEXT

+

+; This looks like multi-line, but because the newline following the last

+; line is discarded, it will be converted into a single line entry.

+another-2=This is not a multiline entry.

+

+; If you wanted a multiline entry with a single line, you need to add 

+; an extra line to it.

+another-3=<<<SI-END-OF-MULTILINE-TEXT

+This is a multiline entry.

+

+SI-END-OF-MULTILINE-TEXT

diff --git a/test1-input.ini b/test1-input.ini
new file mode 100644
index 0000000..a79f06b
--- /dev/null
+++ b/test1-input.ini
@@ -0,0 +1,63 @@
+; testsi-UTF8-std.ini : standard UTF-8 test file for SimpleIni automated testing

+;

+; The number after a section or key is the order that it is defined in this file

+; to make it easier to see if it has been written out correctly. This file should

+; be loaded with Unicode / MultiKey / MultiLine turned on.

+

+; Key with no section

+lonely-key = nosection

+another = nosection either

+

+; This is a section of keys showing the word Japanese in different syllabies.

+[ordered-1]

+a-1 = blah

+

+; this is in kanji

+japanese-2 = 日本語

+

+; this is in hiragana

+japanese-3 = にほんご

+

+; this is in katakana

+japanese-4 = ニホンゴ

+

+; this is in romaji

+japanese-5 = nihongo

+

+; kanji as the key

+日本語-6 = japanese

+

+[multi-2]

+; value a

+test = a

+; value b

+test = b

+; value c

+test = c

+; value d

+test = d

+

+[multiline-3]

+; This is obviously a multi-line entry

+multiline-1 = <<<MULTI

+

+This is a multi-line comment. It

+will continue until we have the word MULTI

+on a line by itself.

+

+日本語も。

+

+MULTI

+

+; This looks like multi-line, but because the newline following the last

+; line is discarded, it will be converted into a single line entry.

+another-2 = <<<MULTI

+This is not a multiline entry.

+MULTI

+

+; If you wanted a multiline entry with a single line, you need to add 

+; an extra line to it.

+another-3 = <<<MULTI

+This is a multiline entry.

+

+MULTI

diff --git a/test1.cpp b/test1.cpp
new file mode 100644
index 0000000..851b099
--- /dev/null
+++ b/test1.cpp
@@ -0,0 +1,154 @@
+// File:    test1.cpp
+// Library: SimpleIni
+// Author:  Brodie Thiesfield <code@jellycan.com>
+// Source:  http://code.jellycan.com/simpleini/
+//
+// Automated testing for SimpleIni streams
+
+#ifdef _WIN32

+# pragma warning(disable: 4786)

+#endif

+

+#ifndef _WIN32

+# include <unistd.h>

+#endif

+#include <fstream>

+

+#define SI_SUPPORT_IOSTREAMS

+#include "SimpleIni.h"
+

+class Test
+{
+    std::string m_strTest;
+
+public:
+    Test(const char * a_pszName) 
+        : m_strTest(a_pszName) 
+    {
+        printf("%s: test starting\n", m_strTest.c_str());
+    }
+
+    bool Success() 
+    {
+        printf("%s: test succeeded\n", m_strTest.c_str());
+        return false;
+    }
+
+    bool Failure(const char * pszReason) 
+    {
+        printf("%s: test FAILED (%s)\n", m_strTest.c_str(), pszReason);
+        return false;
+    }
+};
+
+bool FileComparisonTest(const char * a_pszFile1, const char * a_pszFile2) {
+    // ensure that the two files are the same
+    try {

+        std::string strFile1, strFile2;

+

+        char szBuf[1024];

+        FILE * fp;

+        

+        fp = fopen(a_pszFile1, "rb");

+        if (!fp) throw false;

+        while (!feof(fp)) {

+            size_t n = fread(szBuf, 1, sizeof(szBuf), fp);

+            strFile1.append(szBuf, n);

+        }

+        fclose(fp);

+

+        fp = fopen(a_pszFile2, "rb");

+        if (!fp) throw false;

+        while (!feof(fp)) {

+            size_t n = fread(szBuf, 1, sizeof(szBuf), fp);

+            strFile2.append(szBuf, n);

+        }

+        fclose(fp);

+

+        if (strFile1 != strFile2) throw false;

+    }

+    catch (...) {

+        return false;

+    }

+

+    return true;

+}

+

+bool FileLoadTest(const char * a_pszFile1, const char * a_pszFile2) {
+    // ensure that the two files load into simpleini the same
+    CSimpleIniA ini(true, true, true);

+    bool b;

+    try {

+        ini.Reset();

+        if (ini.LoadFile(a_pszFile1) < 0) throw "Load failed for file 1";

+        if (ini.SaveFile("test1.ini") < 0) throw "Save failed for file 1";

+

+        ini.Reset();

+        if (ini.LoadFile(a_pszFile2) < 0) throw "Load failed for file 2";

+        if (ini.SaveFile("test2.ini") < 0) throw "Save failed for file 2";

+

+        b = FileComparisonTest("test1.ini", "test2.ini");

+        unlink("test1.ini");

+        unlink("test2.ini");

+

+        if (!b) throw "File comparison failed in FileLoadTest";

+    }

+    catch (...) {

+        return false;

+    }

+

+    return true;

+}
+
+bool TestStreams()
+{
+    const char * rgszTestFile[3] = {
+        "test1-input.ini",
+        "test1-output.ini",
+        "test1-expected.ini"
+    };
+
+    Test oTest("TestStreams");
+
+    CSimpleIniA ini;
+    ini.SetUnicode(true);
+    ini.SetMultiKey(true);
+    ini.SetMultiLine(true);
+
+    // load the file
+    try {

+        std::ifstream infile;

+        infile.open(rgszTestFile[0], std::ifstream::in | std::ifstream::binary);

+        if (ini.Load(infile) < 0) throw false;

+        infile.close();

+    }

+    catch (...) {

+        return oTest.Failure("Failed to load file");

+    }

+

+    // standard contents test

+    //if (!StandardContentsTest(ini, oTest)) {

+    //    return false;

+    //}

+

+    // save the file

+    try {

+        std::ofstream outfile;

+        outfile.open(rgszTestFile[1], std::ofstream::out | std::ofstream::binary);

+        if (ini.Save(outfile) < 0) throw false;
+        outfile.close();

+    }

+    catch (...) {

+        return oTest.Failure("Failed to save file");

+    }

+
+    // file comparison test
+    if (!FileComparisonTest(rgszTestFile[1], rgszTestFile[2])) {
+        return oTest.Failure("Failed file comparison");
+    }
+    if (!FileLoadTest(rgszTestFile[1], rgszTestFile[2])) {
+        return oTest.Failure("Failed file load comparison");
+    }
+
+    return oTest.Success();
+}
diff --git a/testsi-EUCJP.ini b/testsi-EUCJP.ini
new file mode 100644
index 0000000..ee9e987
--- /dev/null
+++ b/testsi-EUCJP.ini
@@ -0,0 +1,52 @@
+; test file for SimpleIni

+

+nosection=ok

+NOSECTION=still ok

+  whitespace  =  ok

+  

+[standard]

+foo=foo1

+standard-1=foo

+���ܸ�=ok1

+

+[Standard]

+Foo=foo2

+standard-2=foo

+���ܸ�=ok2

+

+ [  Whitespace  ]

+    

+a=  

+

+[  whitespace in section name  ]

+  whitespace   in   key name    =     whitespace in value   name     

+  

+; comments

+  ; more  comments

+  

+invalid

+=invalid

+====invalid

+

+[Japanese]

+nihongo = ���ܸ�

+���ܸ�  = ���ܸ�

+

+[���ܸ�]

+nihongo = ���ܸ�

+���ܸ�  = ���ܸ�

+

+[]

+more=no section name

+

+

+

+[MultiLine]

+single = This is a single line.

+multi  = <<<MULTI

+

+This is a multi-line value. It continues until the MULTI tag is found 

+on a line by itself with no whitespace before or after it. This value 

+will be returned to the user with all newlines and whitespace.

+

+MULTI

diff --git a/testsi-SJIS.ini b/testsi-SJIS.ini
new file mode 100644
index 0000000..f723ac6
--- /dev/null
+++ b/testsi-SJIS.ini
@@ -0,0 +1,51 @@
+; test file for SimpleIni

+

+nosection=ok

+NOSECTION=still ok

+  whitespace  =  ok

+  

+[standard]

+foo=foo1

+standard-1=foo

+���{��=ok1

+

+[Standard]

+Foo=foo2

+standard-2=foo

+���{��=ok2

+

+ [  Whitespace  ]

+    

+a=  

+

+[  whitespace in section name  ]

+  whitespace   in   key name    =     whitespace in value   name     

+  

+; comments

+  ; more  comments

+  

+invalid

+=invalid

+====invalid

+

+[Japanese]

+nihongo = ���{��

+���{��  = ���{��

+

+[���{��]

+nihongo = ���{��

+���{��  = ���{��

+

+[]

+more=no section name

+

+

+[MultiLine]

+single = This is a single line.

+multi  = <<<MULTI

+

+This is a multi-line value. It continues until the MULTI tag is found 

+on a line by itself with no whitespace before or after it. This value 

+will be returned to the user with all newlines and whitespace.

+

+MULTI

diff --git a/testsi-UTF8.ini b/testsi-UTF8.ini
new file mode 100644
index 0000000..c010f4e
--- /dev/null
+++ b/testsi-UTF8.ini
@@ -0,0 +1,50 @@
+; test file for SimpleIni

+

+  whitespace  =  ok

+nosection=ok

+NOSECTION=still ok

+  

+[standard]

+foo=foo1

+standard-1=foo

+日本語=ok1

+

+[Standard]

+Foo=foo2

+standard-2=foo

+日本語=ok2

+

+ [  Whitespace  ]

+    

+a=  

+

+[  whitespace in section name  ]

+  whitespace   in   key name    =     whitespace in value   name     

+  

+; comments

+  ; more  comments

+  

+invalid

+=invalid

+====invalid

+

+[Japanese]

+nihongo = 日本語

+日本語  = 日本語

+

+[日本語]

+nihongo = 日本語

+日本語  = 日本語

+

+[]

+more=no section name

+

+[MultiLine]

+single = This is a single line.

+multi  = <<<MULTI

+

+This is a multi-line value. It continues until the MULTI tag is found 

+on a line by itself with no whitespace before or after it. This value 

+will be returned to the user with all newlines and whitespace.

+

+MULTI

diff --git a/testsi.cpp b/testsi.cpp
new file mode 100644
index 0000000..2227d84
--- /dev/null
+++ b/testsi.cpp
@@ -0,0 +1,284 @@
+// File:    testsi.cpp
+// Library: SimpleIni
+// Author:  Brodie Thiesfield <code@jellycan.com>
+// Source:  http://code.jellycan.com/simpleini/
+//
+// Demo of usage
+
+#ifdef _WIN32

+# pragma warning(disable: 4786)

+#endif

+

+#include <locale.h>
+#include <stdio.h>
+
+#define SI_SUPPORT_IOSTREAMS
+#if defined(SI_SUPPORT_IOSTREAMS) && !defined(_UNICODE)
+# include <fstream>
+#endif
+
+//#define SI_CONVERT_GENERIC
+//#define SI_CONVERT_ICU
+//#define SI_CONVERT_WIN32
+#include "SimpleIni.h"
+
+#ifdef _WIN32
+# include <tchar.h>
+#else // !_WIN32
+# define TCHAR      char
+# define _T(x)      x
+# define _tprintf   printf
+# define _tmain     main
+#endif // _WIN32
+
+static void
+Test(
+    CSimpleIni &    ini
+    )
+{
+    const TCHAR *pszSection = 0;
+    const TCHAR *pItem = 0;
+    const TCHAR *pszVal = 0;
+
+    // get the value of the key "foo" in section "standard"
+    bool bHasMulti;
+    pszVal = ini.GetValue(_T("standard"), _T("foo"), 0, &bHasMulti);
+    _tprintf(_T("\n-- Value of standard::foo is '%s' (hasMulti = %d)\n"),
+        pszVal ? pszVal : _T("(null)"), bHasMulti);
+
+    // set the value of the key "foo" in section "standard"
+    ini.SetValue(_T("standard"), _T("foo"), _T("wibble"));
+    pszVal = ini.GetValue(_T("standard"), _T("foo"), 0, &bHasMulti);
+    _tprintf(_T("\n-- Value of standard::foo is '%s' (hasMulti = %d)\n"),
+        pszVal ? pszVal : _T("(null)"), bHasMulti);
+
+    // get all values of the key "foo" in section "standard"
+    CSimpleIni::TNamesDepend values;
+    if (ini.GetAllValues(_T("standard"), _T("foo"), values)) {
+        _tprintf(_T("\n-- Values of standard::foo are:\n"));
+        CSimpleIni::TNamesDepend::const_iterator i = values.begin();
+        for (; i != values.end(); ++i) {
+            pszVal = i->pItem;
+            _tprintf(_T("   -> '%s'\n"), pszVal);
+        }
+    }
+
+    // get the size of the section [standard]
+    _tprintf(_T("\n-- Number of keys in section [standard] = %d\n"),
+        ini.GetSectionSize(_T("standard")));
+
+    // delete the key "foo" in section "standard"
+    ini.Delete(_T("standard"), _T("foo"));
+    pszVal = ini.GetValue(_T("standard"), _T("foo"), 0);
+    _tprintf(_T("\n-- Value of standard::foo is now '%s'\n"),
+        pszVal ? pszVal : _T("(null)"));
+
+    // get the size of the section [standard]
+    _tprintf(_T("\n-- Number of keys in section [standard] = %d\n"),
+        ini.GetSectionSize(_T("standard")));
+
+    // get the list of all key names for the section "standard"
+    _tprintf(_T("\n-- Dumping keys of section: [standard]\n"));
+    CSimpleIni::TNamesDepend keys;
+    ini.GetAllKeys(_T("standard"), keys);
+
+    // dump all of the key names
+    CSimpleIni::TNamesDepend::const_iterator iKey = keys.begin();
+    for ( ; iKey != keys.end(); ++iKey ) {
+        pItem = iKey->pItem;
+        _tprintf(_T("Key: %s\n"), pItem);
+    }
+
+    // delete the section "standard"
+    ini.Delete(_T("standard"), NULL);
+    _tprintf(_T("\n-- Number of keys in section [standard] = %d\n"),
+        ini.GetSectionSize(_T("standard")));
+
+    // iterate through every section in the file
+    _tprintf(_T("\n-- Dumping all sections\n"));
+    CSimpleIni::TNamesDepend sections;
+    ini.GetAllSections(sections);
+    CSimpleIni::TNamesDepend::const_iterator iSection = sections.begin();
+    for ( ; iSection != sections.end(); ++iSection ) {
+        pszSection = iSection->pItem;
+
+        // print the section name
+        printf("\n");
+        if (*pszSection) {
+            _tprintf(_T("[%s]\n"), pszSection);
+        }
+
+        // if there are keys and values...
+        const CSimpleIni::TKeyVal * pSectionData = ini.GetSection(pszSection);
+        if (pSectionData) {
+            // iterate over all keys and dump the key name and value
+            CSimpleIni::TKeyVal::const_iterator iKeyVal = pSectionData->begin();
+            for ( ;iKeyVal != pSectionData->end(); ++iKeyVal) {
+                pItem = iKeyVal->first.pItem;
+                pszVal = iKeyVal->second;
+                _tprintf(_T("%s=%s\n"), pItem, pszVal);
+            }
+        }
+    }
+}
+
+#if defined(SI_SUPPORT_IOSTREAMS) && !defined(_UNICODE)
+static bool
+TestStreams(
+    const TCHAR *   a_pszFile,
+    bool            a_bIsUtf8,
+    bool            a_bUseMultiKey,
+    bool            a_bUseMultiLine
+    )
+{
+    // load the file
+    CSimpleIni ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
+    _tprintf(_T("Loading file: %s\n"), a_pszFile);
+    std::ifstream infile;

+    infile.open(a_pszFile, std::ifstream::in | std::ifstream::binary);

+    SI_Error rc = ini.Load(infile);

+    infile.close();

+    if (rc < 0) {
+        printf("Failed to open file.\n");
+        return false;
+    }
+

+    Test(ini);

+

+    // save the file (simple)
+    _tprintf(_T("\n-- Saving file to: testsi-out-streams.ini\n"));
+    std::ofstream outfile;

+    outfile.open("testsi-out-streams.ini", std::ofstream::out | std::ofstream::binary);

+    ini.Save(outfile);
+    outfile.close();

+

+    return true;

+}

+#endif // SI_SUPPORT_IOSTREAMS
+
+static bool
+TestFile(
+    const TCHAR *   a_pszFile,
+    bool            a_bIsUtf8,
+    bool            a_bUseMultiKey,
+    bool            a_bUseMultiLine
+    )
+{
+    // load the file
+    CSimpleIni ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
+    _tprintf(_T("Loading file: %s\n"), a_pszFile);
+    SI_Error rc = ini.LoadFile(a_pszFile);
+    if (rc < 0) {
+        printf("Failed to open file.\n");
+        return false;
+    }
+
+    // run the tests
+    Test(ini);
+
+    // save the file (simple)
+    _tprintf(_T("\n-- Saving file to: testsi-out.ini\n"));
+    ini.SaveFile("testsi-out.ini");
+
+    // save the file (with comments)
+    // Note: to save the file and add a comment to the beginning, use
+    // code such as the following.
+    _tprintf(_T("\n-- Saving file to: testsi-out-comment.ini\n"));
+    FILE * fp = fopen("testsi-out-comment.ini", "wb");
+    if (fp) {
+        // add a string to the file in the correct text format
+        CSimpleIni::Converter convert = ini.GetConverter();
+        convert.ConvertToStore(_T("; output from testsi.cpp test program")
+            SI_NEWLINE SI_NEWLINE);
+
+        CSimpleIni::FileWriter writer(fp);
+        if (a_bIsUtf8) {
+            writer.Write(SI_BOM_UTF8);
+        }
+        writer.Write(convert.Data());
+        ini.Save(writer);
+
+        fclose(fp);
+    }
+
+    return true;
+}
+
+static bool
+ParseCommandLine(
+    int                 argc,
+    TCHAR *             argv[],
+    const TCHAR * &     a_pszFile,
+    bool &              a_bIsUtf8,
+    bool &              a_bUseMultiKey,
+    bool &              a_bUseMultiLine
+    )
+{
+    a_pszFile = 0;
+    a_bIsUtf8 = false;
+    a_bUseMultiKey = false;
+    a_bUseMultiLine = false;
+    for (--argc; argc > 0; --argc) {
+        if (argv[argc][0] == '-') {
+            switch (argv[argc][1]) {
+            case TCHAR('u'):
+                a_bIsUtf8 = true;
+                break;
+            case TCHAR('m'):
+                a_bUseMultiKey = true;
+                break;
+            case TCHAR('l'):
+                a_bUseMultiLine = true;
+                break;
+            }
+        }
+        else {
+            a_pszFile = argv[argc];
+        }
+    }
+    if (!a_pszFile) {
+        _tprintf(
+            _T("Usage: testsi [-u] [-m] [-l] iniFile\n")
+            _T("   -u  Load file as UTF-8 (Default is to use system locale)\n")
+            _T("   -m  Enable multiple keys\n")
+            _T("   -l  Enable multiple line values\n")
+            );
+        return false;
+    }
+
+    return true;
+}
+
+extern bool TestStreams();
+
+int
+_tmain(
+    int     argc,
+    TCHAR * argv[]
+    )
+{
+    setlocale(LC_ALL, "");
+
+    // start of automated testing...
+    TestStreams();
+
+    // parse the command line
+    const TCHAR * pszFile;
+    bool bIsUtf8, bUseMultiKey, bUseMultiLine;
+    if (!ParseCommandLine(argc, argv, pszFile, bIsUtf8, bUseMultiKey, bUseMultiLine)) {
+        return 1;
+    }
+
+    // run the test
+    if (!TestFile(pszFile, bIsUtf8, bUseMultiKey, bUseMultiLine)) {
+        return 1;
+    }
+#if defined(SI_SUPPORT_IOSTREAMS) && !defined(_UNICODE)
+    if (!TestStreams(pszFile, bIsUtf8, bUseMultiKey, bUseMultiLine)) {
+        return 1;
+    }
+#endif
+
+    return 0;
+}
+