Manual whitespace fixes (fix_whitespace.py).

4 files changed, 2849 insertions, 2849 deletions

diff --git a/indra/llcommon/llevents.h b/indra/llcommon/llevents.h
index 1fc0f23ecd..457ecc2248 100644
--- a/indra/llcommon/llevents.h
+++ b/indra/llcommon/llevents.h
@@ -6,25 +6,25 @@
  *         https://wiki.lindenlab.com/wiki/Viewer:Messaging/Event_System,
  *         originally introduced in llnotifications.h. It has nothing
  *         whatsoever to do with the older system in llevent.h.
- * 
+ *
  * $LicenseInfo:firstyear=2008&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -39,13 +39,13 @@
 #include <deque>
 #include <functional>
 #if LL_WINDOWS
-	#pragma warning (push)
-	#pragma warning (disable : 4263) // boost::signals2::expired_slot::what() has const mismatch
-	#pragma warning (disable : 4264) 
+    #pragma warning (push)
+    #pragma warning (disable : 4263) // boost::signals2::expired_slot::what() has const mismatch
+    #pragma warning (disable : 4264)
 #endif
 #include <boost/signals2.hpp>
 #if LL_WINDOWS
-	#pragma warning (pop)
+    #pragma warning (pop)
 #endif
 
 #include <boost/optional/optional.hpp>
@@ -298,9 +298,9 @@ public:
     /**
      * Find the named LLEventPump instance. If it exists post the message to it.
      * If the pump does not exist, do nothing.
-     * 
+     *
      * returns the result of the LLEventPump::post. If no pump exists returns false.
-     * 
+     *
      * This is syntactically similar to LLEventPumps::instance().post(name, message),
      * however if the pump does not already exist it will not be created.
      */
@@ -529,10 +529,10 @@ public:
      * instantiate your listener, then passing the same name on each listen()
      * call, allows us to optimize away the second and subsequent dependency
      * sorts.
-     * 
-     * If name is set to LLEventPump::ANONYMOUS listen will bypass the entire 
-     * dependency and ordering calculation. In this case, it is critical that 
-     * the result be assigned to a LLTempBoundListener or the listener is 
+     *
+     * If name is set to LLEventPump::ANONYMOUS listen will bypass the entire
+     * dependency and ordering calculation. In this case, it is critical that
+     * the result be assigned to a LLTempBoundListener or the listener is
      * manually disconnected when no longer needed since there will be no
      * way to later find and disconnect this listener manually.
      */
@@ -595,7 +595,7 @@ protected:
     virtual LLBoundListener listen_impl(const std::string& name, const LLEventListener&,
                                         const NameList& after,
                                         const NameList& before);
-    
+
     /// implement the dispatching
     std::shared_ptr<LLStandardSignal> mSignal;
 
@@ -648,21 +648,21 @@ public:
  * by all listeners, until some listener consumes it. The caveat is that each
  * event *must* eventually reach a listener that will consume it, else the
  * queue will grow to arbitrary length.
- * 
+ *
  * @NOTE: When using an LLEventMailDrop with an LLEventTimeout or
  * LLEventFilter attaching the filter downstream, using Timeout's constructor will
- * cause the MailDrop to discharge any of its stored events. The timeout should 
- * instead be connected upstream using its listen() method.  
+ * cause the MailDrop to discharge any of its stored events. The timeout should
+ * instead be connected upstream using its listen() method.
  */
 class LL_COMMON_API LLEventMailDrop : public LLEventStream
 {
 public:
     LLEventMailDrop(const std::string& name, bool tweak = false) : LLEventStream(name, tweak) {}
     virtual ~LLEventMailDrop() {}
-    
+
     /// Post an event to all listeners
     virtual bool post(const LLSD& event) override;
-    
+
     /// Remove any history stored in the mail drop.
     void discard();
 
diff --git a/indra/llcommon/llrefcount.h b/indra/llcommon/llrefcount.h
index 5789b5de2c..7ac080b5d6 100644
--- a/indra/llcommon/llrefcount.h
+++ b/indra/llcommon/llrefcount.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llrefcount.h
  * @brief Base class for reference counted objects for use with LLPointer
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -45,42 +45,42 @@ extern const S32 gMaxRefCount;
 class LL_COMMON_API LLRefCount
 {
 protected:
-	LLRefCount(const LLRefCount& other);
-	LLRefCount& operator=(const LLRefCount&);
-	virtual ~LLRefCount(); // use unref()
-	
+    LLRefCount(const LLRefCount& other);
+    LLRefCount& operator=(const LLRefCount&);
+    virtual ~LLRefCount(); // use unref()
+
 public:
-	LLRefCount();
-
-	inline void ref() const
-	{
-		llassert(mRef != LL_REFCOUNT_FREE); // object is deleted
-		mRef++;
-		llassert(mRef < gMaxRefCount); // ref count excessive, likely memory leak
-	}
-
-	inline S32 unref() const
-	{
-		llassert(mRef != LL_REFCOUNT_FREE); // object is deleted
-		llassert(mRef > 0); // ref count below 1, likely corrupted
-		if (0 == --mRef)
-		{
-			mRef = LL_REFCOUNT_FREE; // set to nonsense yet recognizable value to aid in debugging
-			delete this;
-			return 0;
-		}
-		return mRef;
-	}
-
-	//NOTE: when passing around a const LLRefCount object, this can return different results
-	// at different types, since mRef is mutable
-	S32 getNumRefs() const
-	{
-		return mRef;
-	}
+    LLRefCount();
+
+    inline void ref() const
+    {
+        llassert(mRef != LL_REFCOUNT_FREE); // object is deleted
+        mRef++;
+        llassert(mRef < gMaxRefCount); // ref count excessive, likely memory leak
+    }
+
+    inline S32 unref() const
+    {
+        llassert(mRef != LL_REFCOUNT_FREE); // object is deleted
+        llassert(mRef > 0); // ref count below 1, likely corrupted
+        if (0 == --mRef)
+        {
+            mRef = LL_REFCOUNT_FREE; // set to nonsense yet recognizable value to aid in debugging
+            delete this;
+            return 0;
+        }
+        return mRef;
+    }
+
+    //NOTE: when passing around a const LLRefCount object, this can return different results
+    // at different types, since mRef is mutable
+    S32 getNumRefs() const
+    {
+        return mRef;
+    }
 
 private:
-	mutable S32	mRef;
+    mutable S32 mRef;
 };
 
 
@@ -91,50 +91,50 @@ private:
 class LL_COMMON_API LLThreadSafeRefCount
 {
 public:
-	static void initThreadSafeRefCount(); // creates sMutex
-	static void cleanupThreadSafeRefCount(); // destroys sMutex
+    static void initThreadSafeRefCount(); // creates sMutex
+    static void cleanupThreadSafeRefCount(); // destroys sMutex
 
 private:
-	static LLMutex* sMutex;
+    static LLMutex* sMutex;
 
 protected:
-	virtual ~LLThreadSafeRefCount(); // use unref()
+    virtual ~LLThreadSafeRefCount(); // use unref()
 
 public:
-	LLThreadSafeRefCount();
-	LLThreadSafeRefCount(const LLThreadSafeRefCount&);
-	LLThreadSafeRefCount& operator=(const LLThreadSafeRefCount& ref)
-	{
-		mRef = 0;
-		return *this;
-	}
-
-	void ref()
-	{
-		mRef++;
-	}
-
-	void unref()
-	{
-		llassert(mRef >= 1);
-		if ((--mRef) == 0)
-		{
-			// If we hit zero, the caller should be the only smart pointer owning the object and we can delete it.
-			// It is technically possible for a vanilla pointer to mess this up, or another thread to
-			// jump in, find this object, create another smart pointer and end up dangling, but if
-			// the code is that bad and not thread-safe, it's trouble already.
-			delete this;
-		}
-	}
-
-	S32 getNumRefs() const
-	{
-		const S32 currentVal = mRef.CurrentValue();
-		return currentVal;
-	}
+    LLThreadSafeRefCount();
+    LLThreadSafeRefCount(const LLThreadSafeRefCount&);
+    LLThreadSafeRefCount& operator=(const LLThreadSafeRefCount& ref)
+    {
+        mRef = 0;
+        return *this;
+    }
+
+    void ref()
+    {
+        mRef++;
+    }
+
+    void unref()
+    {
+        llassert(mRef >= 1);
+        if ((--mRef) == 0)
+        {
+            // If we hit zero, the caller should be the only smart pointer owning the object and we can delete it.
+            // It is technically possible for a vanilla pointer to mess this up, or another thread to
+            // jump in, find this object, create another smart pointer and end up dangling, but if
+            // the code is that bad and not thread-safe, it's trouble already.
+            delete this;
+        }
+    }
+
+    S32 getNumRefs() const
+    {
+        const S32 currentVal = mRef.CurrentValue();
+        return currentVal;
+    }
 
 private:
-	LLAtomicS32 mRef;
+    LLAtomicS32 mRef;
 };
 
 /**
@@ -143,12 +143,12 @@ private:
  */
 inline void intrusive_ptr_add_ref(LLThreadSafeRefCount* p)
 {
-	p->ref();
+    p->ref();
 }
 
 inline void intrusive_ptr_release(LLThreadSafeRefCount* p)
 {
-	p->unref();
+    p->unref();
 }
 
 /**
@@ -157,12 +157,12 @@ inline void intrusive_ptr_release(LLThreadSafeRefCount* p)
  */
 inline void intrusive_ptr_add_ref(LLRefCount* p)
 {
-	p->ref();
+    p->ref();
 }
 
 inline void intrusive_ptr_release(LLRefCount* p)
 {
-	p->unref();
+    p->unref();
 }
 
 #endif
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 9478dff871..196fd1eea8 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llstring.h
  * @brief String utility functions and std::string class.
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -61,85 +61,85 @@ namespace std
 template<>
 struct char_traits<U16>
 {
-	typedef U16 		char_type;
-	typedef int 	    int_type;
-	typedef streampos 	pos_type;
-	typedef streamoff 	off_type;
-	typedef mbstate_t 	state_type;
-	
-	static void 
-		assign(char_type& __c1, const char_type& __c2)
-	{ __c1 = __c2; }
-	
-	static bool 
-		eq(const char_type& __c1, const char_type& __c2)
-	{ return __c1 == __c2; }
-	
-	static bool 
-		lt(const char_type& __c1, const char_type& __c2)
-	{ return __c1 < __c2; }
-	
-	static int 
-		compare(const char_type* __s1, const char_type* __s2, size_t __n)
-	{ return memcmp(__s1, __s2, __n * sizeof(char_type)); }
-	
-	static size_t
-		length(const char_type* __s)
-	{
-		const char_type *cur_char = __s;
-		while (*cur_char != 0)
-		{
-			++cur_char;
-		}
-		return cur_char - __s;
-	}
-	
-	static const char_type* 
-		find(const char_type* __s, size_t __n, const char_type& __a)
-	{ return static_cast<const char_type*>(memchr(__s, __a, __n * sizeof(char_type))); }
-	
-	static char_type* 
-		move(char_type* __s1, const char_type* __s2, size_t __n)
-	{ return static_cast<char_type*>(memmove(__s1, __s2, __n * sizeof(char_type))); }
-	
-	static char_type* 
-		copy(char_type* __s1, const char_type* __s2, size_t __n)
-	{  return static_cast<char_type*>(memcpy(__s1, __s2, __n * sizeof(char_type))); }	/* Flawfinder: ignore */
-	
-	static char_type* 
-		assign(char_type* __s, size_t __n, char_type __a)
-	{ 
-		// This isn't right.
-		//return static_cast<char_type*>(memset(__s, __a, __n * sizeof(char_type))); 
-		
-		// I don't think there's a standard 'memset' for 16-bit values.
-		// Do this the old-fashioned way.
-		
-		size_t __i;
-		for(__i = 0; __i < __n; __i++)
-		{
-			__s[__i] = __a;
-		}
-		return __s; 
-	}
-	
-	static char_type 
-		to_char_type(const int_type& __c)
-	{ return static_cast<char_type>(__c); }
-	
-	static int_type 
-		to_int_type(const char_type& __c)
-	{ return static_cast<int_type>(__c); }
-	
-	static bool 
-		eq_int_type(const int_type& __c1, const int_type& __c2)
-	{ return __c1 == __c2; }
-	
-	static int_type 
-		eof() { return static_cast<int_type>(EOF); }
-	
-	static int_type 
-		not_eof(const int_type& __c)
+    typedef U16         char_type;
+    typedef int         int_type;
+    typedef streampos   pos_type;
+    typedef streamoff   off_type;
+    typedef mbstate_t   state_type;
+
+    static void
+        assign(char_type& __c1, const char_type& __c2)
+    { __c1 = __c2; }
+
+    static bool
+        eq(const char_type& __c1, const char_type& __c2)
+    { return __c1 == __c2; }
+
+    static bool
+        lt(const char_type& __c1, const char_type& __c2)
+    { return __c1 < __c2; }
+
+    static int
+        compare(const char_type* __s1, const char_type* __s2, size_t __n)
+    { return memcmp(__s1, __s2, __n * sizeof(char_type)); }
+
+    static size_t
+        length(const char_type* __s)
+    {
+        const char_type *cur_char = __s;
+        while (*cur_char != 0)
+        {
+            ++cur_char;
+        }
+        return cur_char - __s;
+    }
+
+    static const char_type*
+        find(const char_type* __s, size_t __n, const char_type& __a)
+    { return static_cast<const char_type*>(memchr(__s, __a, __n * sizeof(char_type))); }
+
+    static char_type*
+        move(char_type* __s1, const char_type* __s2, size_t __n)
+    { return static_cast<char_type*>(memmove(__s1, __s2, __n * sizeof(char_type))); }
+
+    static char_type*
+        copy(char_type* __s1, const char_type* __s2, size_t __n)
+    {  return static_cast<char_type*>(memcpy(__s1, __s2, __n * sizeof(char_type))); }   /* Flawfinder: ignore */
+
+    static char_type*
+        assign(char_type* __s, size_t __n, char_type __a)
+    {
+        // This isn't right.
+        //return static_cast<char_type*>(memset(__s, __a, __n * sizeof(char_type)));
+
+        // I don't think there's a standard 'memset' for 16-bit values.
+        // Do this the old-fashioned way.
+
+        size_t __i;
+        for(__i = 0; __i < __n; __i++)
+        {
+            __s[__i] = __a;
+        }
+        return __s;
+    }
+
+    static char_type
+        to_char_type(const int_type& __c)
+    { return static_cast<char_type>(__c); }
+
+    static int_type
+        to_int_type(const char_type& __c)
+    { return static_cast<int_type>(__c); }
+
+    static bool
+        eq_int_type(const int_type& __c1, const int_type& __c2)
+    { return __c1 == __c2; }
+
+    static int_type
+        eof() { return static_cast<int_type>(EOF); }
+
+    static int_type
+        not_eof(const int_type& __c)
       { return (__c == eof()) ? 0 : __c; }
   };
 };
@@ -148,72 +148,72 @@ struct char_traits<U16>
 class LL_COMMON_API LLStringOps
 {
 private:
-	static long sPacificTimeOffset;
-	static long sLocalTimeOffset;
-	static bool sPacificDaylightTime;
+    static long sPacificTimeOffset;
+    static long sLocalTimeOffset;
+    static bool sPacificDaylightTime;
 
-	static std::map<std::string, std::string> datetimeToCodes;
+    static std::map<std::string, std::string> datetimeToCodes;
 
 public:
-	static std::vector<std::string> sWeekDayList;
-	static std::vector<std::string> sWeekDayShortList;
-	static std::vector<std::string> sMonthList;
-	static std::vector<std::string> sMonthShortList;
-	static std::string sDayFormat;
+    static std::vector<std::string> sWeekDayList;
+    static std::vector<std::string> sWeekDayShortList;
+    static std::vector<std::string> sMonthList;
+    static std::vector<std::string> sMonthShortList;
+    static std::string sDayFormat;
 
-	static std::string sAM;
-	static std::string sPM;
+    static std::string sAM;
+    static std::string sPM;
 
-	static char toUpper(char elem) { return toupper((unsigned char)elem); }
-	static llwchar toUpper(llwchar elem) { return towupper(elem); }
-	
-	static char toLower(char elem) { return tolower((unsigned char)elem); }
-	static llwchar toLower(llwchar elem) { return towlower(elem); }
+    static char toUpper(char elem) { return toupper((unsigned char)elem); }
+    static llwchar toUpper(llwchar elem) { return towupper(elem); }
 
-	static bool isSpace(char elem) { return isspace((unsigned char)elem) != 0; }
-	static bool isSpace(llwchar elem) { return iswspace(elem) != 0; }
+    static char toLower(char elem) { return tolower((unsigned char)elem); }
+    static llwchar toLower(llwchar elem) { return towlower(elem); }
 
-	static bool isUpper(char elem) { return isupper((unsigned char)elem) != 0; }
-	static bool isUpper(llwchar elem) { return iswupper(elem) != 0; }
+    static bool isSpace(char elem) { return isspace((unsigned char)elem) != 0; }
+    static bool isSpace(llwchar elem) { return iswspace(elem) != 0; }
 
-	static bool isLower(char elem) { return islower((unsigned char)elem) != 0; }
-	static bool isLower(llwchar elem) { return iswlower(elem) != 0; }
+    static bool isUpper(char elem) { return isupper((unsigned char)elem) != 0; }
+    static bool isUpper(llwchar elem) { return iswupper(elem) != 0; }
 
-	static bool isDigit(char a) { return isdigit((unsigned char)a) != 0; }
-	static bool isDigit(llwchar a) { return iswdigit(a) != 0; }
+    static bool isLower(char elem) { return islower((unsigned char)elem) != 0; }
+    static bool isLower(llwchar elem) { return iswlower(elem) != 0; }
 
-	static bool isPunct(char a) { return ispunct((unsigned char)a) != 0; }
-	static bool isPunct(llwchar a) { return iswpunct(a) != 0; }
+    static bool isDigit(char a) { return isdigit((unsigned char)a) != 0; }
+    static bool isDigit(llwchar a) { return iswdigit(a) != 0; }
 
-	static bool isAlpha(char a) { return isalpha((unsigned char)a) != 0; }
-	static bool isAlpha(llwchar a) { return iswalpha(a) != 0; }
+    static bool isPunct(char a) { return ispunct((unsigned char)a) != 0; }
+    static bool isPunct(llwchar a) { return iswpunct(a) != 0; }
 
-	static bool isAlnum(char a) { return isalnum((unsigned char)a) != 0; }
-	static bool isAlnum(llwchar a) { return iswalnum(a) != 0; }
+    static bool isAlpha(char a) { return isalpha((unsigned char)a) != 0; }
+    static bool isAlpha(llwchar a) { return iswalpha(a) != 0; }
 
-	static bool isEmoji(llwchar wch);
+    static bool isAlnum(char a) { return isalnum((unsigned char)a) != 0; }
+    static bool isAlnum(llwchar a) { return iswalnum(a) != 0; }
 
-	static S32	collate(const char* a, const char* b) { return strcoll(a, b); }
-	static S32	collate(const llwchar* a, const llwchar* b);
+    static bool isEmoji(llwchar wch);
 
-	static void setupDatetimeInfo(bool pacific_daylight_time);
+    static S32  collate(const char* a, const char* b) { return strcoll(a, b); }
+    static S32  collate(const llwchar* a, const llwchar* b);
 
-	static void setupWeekDaysNames(const std::string& data);
-	static void setupWeekDaysShortNames(const std::string& data);
-	static void setupMonthNames(const std::string& data);
-	static void setupMonthShortNames(const std::string& data);
-	static void setupDayFormat(const std::string& data);
+    static void setupDatetimeInfo(bool pacific_daylight_time);
 
+    static void setupWeekDaysNames(const std::string& data);
+    static void setupWeekDaysShortNames(const std::string& data);
+    static void setupMonthNames(const std::string& data);
+    static void setupMonthShortNames(const std::string& data);
+    static void setupDayFormat(const std::string& data);
 
-	static long getPacificTimeOffset(void) { return sPacificTimeOffset;}
-	static long getLocalTimeOffset(void) { return sLocalTimeOffset;}
-	// Is the Pacific time zone (aka server time zone)
-	// currently in daylight savings time?
-	static bool getPacificDaylightTime(void) { return sPacificDaylightTime;}
 
-	static std::string getDatetimeCode (std::string key);
+    static long getPacificTimeOffset(void) { return sPacificTimeOffset;}
+    static long getLocalTimeOffset(void) { return sLocalTimeOffset;}
+    // Is the Pacific time zone (aka server time zone)
+    // currently in daylight savings time?
+    static bool getPacificDaylightTime(void) { return sPacificDaylightTime;}
 
-    // Express a value like 1234567 as "1.23M" 
+    static std::string getDatetimeCode (std::string key);
+
+    // Express a value like 1234567 as "1.23M"
     static std::string getReadableNumber(F64 num);
 };
 
@@ -230,216 +230,216 @@ LL_COMMON_API std::string ll_safe_string(const char* in, S32 maxlen);
 class LLFormatMapString
 {
 public:
-	LLFormatMapString() {};
-	LLFormatMapString(const char* s) : mString(ll_safe_string(s)) {};
-	LLFormatMapString(const std::string& s) : mString(s) {};
-	operator std::string() const { return mString; }
-	bool operator<(const LLFormatMapString& rhs) const { return mString < rhs.mString; }
-	std::size_t length() const { return mString.length(); }
-	
+    LLFormatMapString() {};
+    LLFormatMapString(const char* s) : mString(ll_safe_string(s)) {};
+    LLFormatMapString(const std::string& s) : mString(s) {};
+    operator std::string() const { return mString; }
+    bool operator<(const LLFormatMapString& rhs) const { return mString < rhs.mString; }
+    std::size_t length() const { return mString.length(); }
+
 private:
-	std::string mString;
+    std::string mString;
 };
 
 template <class T>
 class LLStringUtilBase
 {
 private:
-	static std::string sLocale;
+    static std::string sLocale;
 
 public:
-	typedef std::basic_string<T> string_type;
-	typedef typename string_type::size_type size_type;
-	
+    typedef std::basic_string<T> string_type;
+    typedef typename string_type::size_type size_type;
+
 public:
-	/////////////////////////////////////////////////////////////////////////////////////////
-	// Static Utility functions that operate on std::strings
-
-	static const string_type null;
-	
-	typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
-	/// considers any sequence of delims as a single field separator
-	LL_COMMON_API static void getTokens(const string_type& instr,
-										std::vector<string_type >& tokens,
-										const string_type& delims);
-	/// like simple scan overload, but returns scanned vector
-	static std::vector<string_type> getTokens(const string_type& instr,
-											  const string_type& delims);
-	/// add support for keep_delims and quotes (either could be empty string)
-	static void getTokens(const string_type& instr,
-						  std::vector<string_type>& tokens,
-						  const string_type& drop_delims,
-						  const string_type& keep_delims,
-						  const string_type& quotes=string_type());
-	/// like keep_delims-and-quotes overload, but returns scanned vector
-	static std::vector<string_type> getTokens(const string_type& instr,
-											  const string_type& drop_delims,
-											  const string_type& keep_delims,
-											  const string_type& quotes=string_type());
-	/// add support for escapes (could be empty string)
-	static void getTokens(const string_type& instr,
-						  std::vector<string_type>& tokens,
-						  const string_type& drop_delims,
-						  const string_type& keep_delims,
-						  const string_type& quotes,
-						  const string_type& escapes);
-	/// like escapes overload, but returns scanned vector
-	static std::vector<string_type> getTokens(const string_type& instr,
-											  const string_type& drop_delims,
-											  const string_type& keep_delims,
-											  const string_type& quotes,
-											  const string_type& escapes);
-
-	LL_COMMON_API static void formatNumber(string_type& numStr, string_type decimals);
-	LL_COMMON_API static bool formatDatetime(string_type& replacement, string_type token, string_type param, S32 secFromEpoch);
-	LL_COMMON_API static S32 format(string_type& s, const format_map_t& substitutions);
-	LL_COMMON_API static S32 format(string_type& s, const LLSD& substitutions);
-	LL_COMMON_API static bool simpleReplacement(string_type& replacement, string_type token, const format_map_t& substitutions);
-	LL_COMMON_API static bool simpleReplacement(string_type& replacement, string_type token, const LLSD& substitutions);
-	LL_COMMON_API static void setLocale (std::string inLocale);
-	LL_COMMON_API static std::string getLocale (void);
-	
-	static bool isValidIndex(const string_type& string, size_type i)
-	{
-		return !string.empty() && (0 <= i) && (i <= string.size());
-	}
-
-	static bool contains(const string_type& string, T c, size_type i=0)
-	{
-		return string.find(c, i) != string_type::npos;
-	}
-
-	static void	trimHead(string_type& string);
-	static void	trimTail(string_type& string);
-	static void	trim(string_type& string)	{ trimHead(string); trimTail(string); }
-	static void truncate(string_type& string, size_type count);
-
-	static void	toUpper(string_type& string);
-	static void	toLower(string_type& string);
-	
-	// True if this is the head of s.
-	static BOOL	isHead( const string_type& string, const T* s ); 
-
-	/**
-	 * @brief Returns true if string starts with substr
-	 *
-	 * If etither string or substr are empty, this method returns false.
-	 */
-	static bool startsWith(
-		const string_type& string,
-		const string_type& substr);
-
-	/**
-	 * @brief Returns true if string ends in substr
-	 *
-	 * If etither string or substr are empty, this method returns false.
-	 */
-	static bool endsWith(
-		const string_type& string,
-		const string_type& substr);
-
-	/**
-	 * get environment string value with proper Unicode handling
-	 * (key is always UTF-8)
-	 * detect absence by return value == dflt
-	 */
-	static string_type getenv(const std::string& key, const string_type& dflt="");
-	/**
-	 * get optional environment string value with proper Unicode handling
-	 * (key is always UTF-8)
-	 * detect absence by (! return value)
-	 */
-	static boost::optional<string_type> getoptenv(const std::string& key);
-
-	static void	addCRLF(string_type& string);
-	static void	removeCRLF(string_type& string);
-	static void removeWindowsCR(string_type& string);
-
-	static void	replaceTabsWithSpaces( string_type& string, size_type spaces_per_tab );
-	static void	replaceNonstandardASCII( string_type& string, T replacement );
-	static void	replaceChar( string_type& string, T target, T replacement );
-	static void replaceString( string_type& string, string_type target, string_type replacement );
-	static string_type capitalize(const string_type& str);
-	static void capitalize(string_type& str);
-	
-	static BOOL	containsNonprintable(const string_type& string);
-	static void	stripNonprintable(string_type& string);
-
-	/**
-	 * Double-quote an argument string if needed, unless it's already
-	 * double-quoted. Decide whether it's needed based on the presence of any
-	 * character in @a triggers (default space or double-quote). If we quote
-	 * it, escape any embedded double-quote with the @a escape string (default
-	 * backslash).
-	 *
-	 * Passing triggers="" means always quote, unless it's already double-quoted.
-	 */
-	static string_type quote(const string_type& str,
-							 const string_type& triggers=" \"",
-							 const string_type& escape="\\");
-
-	/**
-	 * @brief Unsafe way to make ascii characters. You should probably
-	 * only call this when interacting with the host operating system.
-	 * The 1 byte std::string does not work correctly.
-	 * The 2 and 4 byte std::string probably work, so LLWStringUtil::_makeASCII
-	 * should work.
-	 */
-	static void _makeASCII(string_type& string);
-
-	// Conversion to other data types
-	static BOOL	convertToBOOL(const string_type& string, BOOL& value);
-	static BOOL	convertToU8(const string_type& string, U8& value);
-	static BOOL	convertToS8(const string_type& string, S8& value);
-	static BOOL	convertToS16(const string_type& string, S16& value);
-	static BOOL	convertToU16(const string_type& string, U16& value);
-	static BOOL	convertToU32(const string_type& string, U32& value);
-	static BOOL	convertToS32(const string_type& string, S32& value);
-	static BOOL	convertToF32(const string_type& string, F32& value);
-	static BOOL	convertToF64(const string_type& string, F64& value);
-
-	/////////////////////////////////////////////////////////////////////////////////////////
-	// Utility functions for working with char*'s and strings
-
-	// Like strcmp but also handles empty strings. Uses
-	// current locale.
-	static S32		compareStrings(const T* lhs, const T* rhs);
-	static S32		compareStrings(const string_type& lhs, const string_type& rhs);
-	
-	// case insensitive version of above. Uses current locale on
-	// Win32, and falls back to a non-locale aware comparison on
-	// Linux.
-	static S32		compareInsensitive(const T* lhs, const T* rhs);
-	static S32		compareInsensitive(const string_type& lhs, const string_type& rhs);
-
-	// Case sensitive comparison with good handling of numbers.  Does not use current locale.
-	// a.k.a. strdictcmp()
-	static S32		compareDict(const string_type& a, const string_type& b);
-
-	// Case *in*sensitive comparison with good handling of numbers.  Does not use current locale.
-	// a.k.a. strdictcmp()
-	static S32		compareDictInsensitive(const string_type& a, const string_type& b);
-
-	// Puts compareDict() in a form appropriate for LL container classes to use for sorting.
-	static BOOL		precedesDict( const string_type& a, const string_type& b );
-
-	// A replacement for strncpy.
-	// If the dst buffer is dst_size bytes long or more, ensures that dst is null terminated and holds
-	// up to dst_size-1 characters of src.
-	static void		copy(T* dst, const T* src, size_type dst_size);
-	
-	// Copies src into dst at a given offset.  
-	static void		copyInto(string_type& dst, const string_type& src, size_type offset);
-	
-	static bool		isPartOfWord(T c) { return (c == (T)'_') || LLStringOps::isAlnum(c); }
-
-
-#ifdef _DEBUG	
-	LL_COMMON_API static void		testHarness();
+    /////////////////////////////////////////////////////////////////////////////////////////
+    // Static Utility functions that operate on std::strings
+
+    static const string_type null;
+
+    typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
+    /// considers any sequence of delims as a single field separator
+    LL_COMMON_API static void getTokens(const string_type& instr,
+                                        std::vector<string_type >& tokens,
+                                        const string_type& delims);
+    /// like simple scan overload, but returns scanned vector
+    static std::vector<string_type> getTokens(const string_type& instr,
+                                              const string_type& delims);
+    /// add support for keep_delims and quotes (either could be empty string)
+    static void getTokens(const string_type& instr,
+                          std::vector<string_type>& tokens,
+                          const string_type& drop_delims,
+                          const string_type& keep_delims,
+                          const string_type& quotes=string_type());
+    /// like keep_delims-and-quotes overload, but returns scanned vector
+    static std::vector<string_type> getTokens(const string_type& instr,
+                                              const string_type& drop_delims,
+                                              const string_type& keep_delims,
+                                              const string_type& quotes=string_type());
+    /// add support for escapes (could be empty string)
+    static void getTokens(const string_type& instr,
+                          std::vector<string_type>& tokens,
+                          const string_type& drop_delims,
+                          const string_type& keep_delims,
+                          const string_type& quotes,
+                          const string_type& escapes);
+    /// like escapes overload, but returns scanned vector
+    static std::vector<string_type> getTokens(const string_type& instr,
+                                              const string_type& drop_delims,
+                                              const string_type& keep_delims,
+                                              const string_type& quotes,
+                                              const string_type& escapes);
+
+    LL_COMMON_API static void formatNumber(string_type& numStr, string_type decimals);
+    LL_COMMON_API static bool formatDatetime(string_type& replacement, string_type token, string_type param, S32 secFromEpoch);
+    LL_COMMON_API static S32 format(string_type& s, const format_map_t& substitutions);
+    LL_COMMON_API static S32 format(string_type& s, const LLSD& substitutions);
+    LL_COMMON_API static bool simpleReplacement(string_type& replacement, string_type token, const format_map_t& substitutions);
+    LL_COMMON_API static bool simpleReplacement(string_type& replacement, string_type token, const LLSD& substitutions);
+    LL_COMMON_API static void setLocale (std::string inLocale);
+    LL_COMMON_API static std::string getLocale (void);
+
+    static bool isValidIndex(const string_type& string, size_type i)
+    {
+        return !string.empty() && (0 <= i) && (i <= string.size());
+    }
+
+    static bool contains(const string_type& string, T c, size_type i=0)
+    {
+        return string.find(c, i) != string_type::npos;
+    }
+
+    static void trimHead(string_type& string);
+    static void trimTail(string_type& string);
+    static void trim(string_type& string)   { trimHead(string); trimTail(string); }
+    static void truncate(string_type& string, size_type count);
+
+    static void toUpper(string_type& string);
+    static void toLower(string_type& string);
+
+    // True if this is the head of s.
+    static BOOL isHead( const string_type& string, const T* s );
+
+    /**
+     * @brief Returns true if string starts with substr
+     *
+     * If etither string or substr are empty, this method returns false.
+     */
+    static bool startsWith(
+        const string_type& string,
+        const string_type& substr);
+
+    /**
+     * @brief Returns true if string ends in substr
+     *
+     * If etither string or substr are empty, this method returns false.
+     */
+    static bool endsWith(
+        const string_type& string,
+        const string_type& substr);
+
+    /**
+     * get environment string value with proper Unicode handling
+     * (key is always UTF-8)
+     * detect absence by return value == dflt
+     */
+    static string_type getenv(const std::string& key, const string_type& dflt="");
+    /**
+     * get optional environment string value with proper Unicode handling
+     * (key is always UTF-8)
+     * detect absence by (! return value)
+     */
+    static boost::optional<string_type> getoptenv(const std::string& key);
+
+    static void addCRLF(string_type& string);
+    static void removeCRLF(string_type& string);
+    static void removeWindowsCR(string_type& string);
+
+    static void replaceTabsWithSpaces( string_type& string, size_type spaces_per_tab );
+    static void replaceNonstandardASCII( string_type& string, T replacement );
+    static void replaceChar( string_type& string, T target, T replacement );
+    static void replaceString( string_type& string, string_type target, string_type replacement );
+    static string_type capitalize(const string_type& str);
+    static void capitalize(string_type& str);
+
+    static BOOL containsNonprintable(const string_type& string);
+    static void stripNonprintable(string_type& string);
+
+    /**
+     * Double-quote an argument string if needed, unless it's already
+     * double-quoted. Decide whether it's needed based on the presence of any
+     * character in @a triggers (default space or double-quote). If we quote
+     * it, escape any embedded double-quote with the @a escape string (default
+     * backslash).
+     *
+     * Passing triggers="" means always quote, unless it's already double-quoted.
+     */
+    static string_type quote(const string_type& str,
+                             const string_type& triggers=" \"",
+                             const string_type& escape="\\");
+
+    /**
+     * @brief Unsafe way to make ascii characters. You should probably
+     * only call this when interacting with the host operating system.
+     * The 1 byte std::string does not work correctly.
+     * The 2 and 4 byte std::string probably work, so LLWStringUtil::_makeASCII
+     * should work.
+     */
+    static void _makeASCII(string_type& string);
+
+    // Conversion to other data types
+    static BOOL convertToBOOL(const string_type& string, BOOL& value);
+    static BOOL convertToU8(const string_type& string, U8& value);
+    static BOOL convertToS8(const string_type& string, S8& value);
+    static BOOL convertToS16(const string_type& string, S16& value);
+    static BOOL convertToU16(const string_type& string, U16& value);
+    static BOOL convertToU32(const string_type& string, U32& value);
+    static BOOL convertToS32(const string_type& string, S32& value);
+    static BOOL convertToF32(const string_type& string, F32& value);
+    static BOOL convertToF64(const string_type& string, F64& value);
+
+    /////////////////////////////////////////////////////////////////////////////////////////
+    // Utility functions for working with char*'s and strings
+
+    // Like strcmp but also handles empty strings. Uses
+    // current locale.
+    static S32      compareStrings(const T* lhs, const T* rhs);
+    static S32      compareStrings(const string_type& lhs, const string_type& rhs);
+
+    // case insensitive version of above. Uses current locale on
+    // Win32, and falls back to a non-locale aware comparison on
+    // Linux.
+    static S32      compareInsensitive(const T* lhs, const T* rhs);
+    static S32      compareInsensitive(const string_type& lhs, const string_type& rhs);
+
+    // Case sensitive comparison with good handling of numbers.  Does not use current locale.
+    // a.k.a. strdictcmp()
+    static S32      compareDict(const string_type& a, const string_type& b);
+
+    // Case *in*sensitive comparison with good handling of numbers.  Does not use current locale.
+    // a.k.a. strdictcmp()
+    static S32      compareDictInsensitive(const string_type& a, const string_type& b);
+
+    // Puts compareDict() in a form appropriate for LL container classes to use for sorting.
+    static BOOL     precedesDict( const string_type& a, const string_type& b );
+
+    // A replacement for strncpy.
+    // If the dst buffer is dst_size bytes long or more, ensures that dst is null terminated and holds
+    // up to dst_size-1 characters of src.
+    static void     copy(T* dst, const T* src, size_type dst_size);
+
+    // Copies src into dst at a given offset.
+    static void     copyInto(string_type& dst, const string_type& src, size_type offset);
+
+    static bool     isPartOfWord(T c) { return (c == (T)'_') || LLStringOps::isAlnum(c); }
+
+
+#ifdef _DEBUG
+    LL_COMMON_API static void       testHarness();
 #endif
 
 private:
-	LL_COMMON_API static size_type getSubstitution(const string_type& instr, size_type& start, std::vector<string_type >& tokens);
+    LL_COMMON_API static size_type getSubstitution(const string_type& instr, size_type& start, std::vector<string_type >& tokens);
 };
 
 template<class T> const std::basic_string<T> LLStringUtilBase<T>::null;
@@ -455,18 +455,18 @@ typedef std::basic_string<llwchar> LLWString;
 class LLStringExplicit : public std::string
 {
 public:
-	explicit LLStringExplicit(const char* s) : std::string(s) {}
-	LLStringExplicit(const std::string& s) : std::string(s) {}
-	LLStringExplicit(const std::string& s, size_type pos, size_type n = std::string::npos) : std::string(s, pos, n) {}
+    explicit LLStringExplicit(const char* s) : std::string(s) {}
+    LLStringExplicit(const std::string& s) : std::string(s) {}
+    LLStringExplicit(const std::string& s, size_type pos, size_type n = std::string::npos) : std::string(s, pos, n) {}
 };
 
 struct LLDictionaryLess
 {
 public:
-	bool operator()(const std::string& a, const std::string& b) const
-	{
-		return (LLStringUtil::precedesDict(a, b) ? true : false);
-	}
+    bool operator()(const std::string& a, const std::string& b) const
+    {
+        return (LLStringUtil::precedesDict(a, b) ? true : false);
+    }
 };
 
 
@@ -483,10 +483,10 @@ public:
  * @return a copy of in string minus the trailing count bytes.
  */
 inline std::string chop_tail_copy(
-	const std::string& in,
-	std::string::size_type count)
+    const std::string& in,
+    std::string::size_type count)
 {
-	return std::string(in, 0, in.length() - count);
+    return std::string(in, 0, in.length() - count);
 }
 
 /**
@@ -706,10 +706,10 @@ ll_convert_forms(ll_convert_u16_alias, std::string, llutf16string, utf16str_to_u
 inline std::string wstring_to_utf8str(const llutf16string &utf16str) { return utf16str_to_utf8str(utf16str);}
 
 // Length of this UTF32 string in bytes when transformed to UTF8
-LL_COMMON_API S32 wstring_utf8_length(const LLWString& wstr); 
+LL_COMMON_API S32 wstring_utf8_length(const LLWString& wstr);
 
 // Length in bytes of this wide char in a UTF8 string
-LL_COMMON_API S32 wchar_utf8_length(const llwchar wc); 
+LL_COMMON_API S32 wchar_utf8_length(const llwchar wc);
 
 LL_COMMON_API std::string wchar_utf8_preview(const llwchar wc);
 
@@ -726,7 +726,7 @@ LL_COMMON_API S32 wstring_wstring_length_from_utf16_length(const LLWString & wst
 
 /**
  * @brief Properly truncate a utf8 string to a maximum byte count.
- * 
+ *
  * The returned string may be less than max_len if the truncation
  * happens in the middle of a glyph. If max_len is longer than the
  * string passed in, the return value == utf8str.
@@ -739,8 +739,8 @@ LL_COMMON_API std::string utf8str_truncate(const std::string& utf8str, const S32
 LL_COMMON_API std::string utf8str_trim(const std::string& utf8str);
 
 LL_COMMON_API S32 utf8str_compare_insensitive(
-	const std::string& lhs,
-	const std::string& rhs);
+    const std::string& lhs,
+    const std::string& rhs);
 
 /**
 * @brief Properly truncate a utf8 string to a maximum character count.
@@ -761,14 +761,14 @@ LL_COMMON_API std::string utf8str_symbol_truncate(const std::string& utf8str, co
  * @param replace_char The wchar which is written on replace
  */
 LL_COMMON_API std::string utf8str_substChar(
-	const std::string& utf8str,
-	const llwchar target_char,
-	const llwchar replace_char);
+    const std::string& utf8str,
+    const llwchar target_char,
+    const llwchar replace_char);
 
 LL_COMMON_API std::string utf8str_makeASCII(const std::string& utf8str);
 
 // Hack - used for evil notecards.
-LL_COMMON_API std::string mbcsstring_makeASCII(const std::string& str); 
+LL_COMMON_API std::string mbcsstring_makeASCII(const std::string& str);
 
 LL_COMMON_API std::string utf8str_removeCRLF(const std::string& utf8str);
 
@@ -874,52 +874,52 @@ LL_COMMON_API boost::optional<std::string>  llstring_getoptenv(const std::string
  */
 namespace LLStringFn
 {
-	/**
-	 * @brief Replace all non-printable characters with replacement in
-	 * string.
-	 * NOTE - this will zap non-ascii
-	 *
-	 * @param [in,out] string the to modify. out value is the string
-	 * with zero non-printable characters.
-	 * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
-	 */
-	LL_COMMON_API void replace_nonprintable_in_ascii(
-		std::basic_string<char>& string,
-		char replacement);
-
-
-	/**
-	 * @brief Replace all non-printable characters and pipe characters
-	 * with replacement in a string.
-	 * NOTE - this will zap non-ascii
-	 *
-	 * @param [in,out] the string to modify. out value is the string
-	 * with zero non-printable characters and zero pipe characters.
-	 * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
-	 */
-	LL_COMMON_API void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
-									   char replacement);
-
-
-	/**
-	 * @brief Remove all characters that are not allowed in XML 1.0.
-	 * Returns a copy of the string with those characters removed.
-	 * Works with US ASCII and UTF-8 encoded strings.  JC
-	 */
-	LL_COMMON_API std::string strip_invalid_xml(const std::string& input);
-
-
-	/**
-	 * @brief Replace all control characters (0 <= c < 0x20) with replacement in
-	 * string.   This is safe for utf-8
-	 *
-	 * @param [in,out] string the to modify. out value is the string
-	 * with zero non-printable characters.
-	 * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
-	 */
-	LL_COMMON_API void replace_ascii_controlchars(
-		std::basic_string<char>& string,
-		char replacement);
+    /**
+     * @brief Replace all non-printable characters with replacement in
+     * string.
+     * NOTE - this will zap non-ascii
+     *
+     * @param [in,out] string the to modify. out value is the string
+     * with zero non-printable characters.
+     * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
+     */
+    LL_COMMON_API void replace_nonprintable_in_ascii(
+        std::basic_string<char>& string,
+        char replacement);
+
+
+    /**
+     * @brief Replace all non-printable characters and pipe characters
+     * with replacement in a string.
+     * NOTE - this will zap non-ascii
+     *
+     * @param [in,out] the string to modify. out value is the string
+     * with zero non-printable characters and zero pipe characters.
+     * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
+     */
+    LL_COMMON_API void replace_nonprintable_and_pipe_in_ascii(std::basic_string<char>& str,
+                                       char replacement);
+
+
+    /**
+     * @brief Remove all characters that are not allowed in XML 1.0.
+     * Returns a copy of the string with those characters removed.
+     * Works with US ASCII and UTF-8 encoded strings.  JC
+     */
+    LL_COMMON_API std::string strip_invalid_xml(const std::string& input);
+
+
+    /**
+     * @brief Replace all control characters (0 <= c < 0x20) with replacement in
+     * string.   This is safe for utf-8
+     *
+     * @param [in,out] string the to modify. out value is the string
+     * with zero non-printable characters.
+     * @param The replacement character. use LL_UNKNOWN_CHAR if unsure.
+     */
+    LL_COMMON_API void replace_ascii_controlchars(
+        std::basic_string<char>& string,
+        char replacement);
 }
 
 ////////////////////////////////////////////////////////////
@@ -934,36 +934,36 @@ template <class T>
 std::vector<typename LLStringUtilBase<T>::string_type>
 LLStringUtilBase<T>::getTokens(const string_type& instr, const string_type& delims)
 {
-	std::vector<string_type> tokens;
-	getTokens(instr, tokens, delims);
-	return tokens;
+    std::vector<string_type> tokens;
+    getTokens(instr, tokens, delims);
+    return tokens;
 }
 
 // static
 template <class T>
 std::vector<typename LLStringUtilBase<T>::string_type>
 LLStringUtilBase<T>::getTokens(const string_type& instr,
-							   const string_type& drop_delims,
-							   const string_type& keep_delims,
-							   const string_type& quotes)
+                               const string_type& drop_delims,
+                               const string_type& keep_delims,
+                               const string_type& quotes)
 {
-	std::vector<string_type> tokens;
-	getTokens(instr, tokens, drop_delims, keep_delims, quotes);
-	return tokens;
+    std::vector<string_type> tokens;
+    getTokens(instr, tokens, drop_delims, keep_delims, quotes);
+    return tokens;
 }
 
 // static
 template <class T>
 std::vector<typename LLStringUtilBase<T>::string_type>
 LLStringUtilBase<T>::getTokens(const string_type& instr,
-							   const string_type& drop_delims,
-							   const string_type& keep_delims,
-							   const string_type& quotes,
-							   const string_type& escapes)
-{
-	std::vector<string_type> tokens;
-	getTokens(instr, tokens, drop_delims, keep_delims, quotes, escapes);
-	return tokens;
+                               const string_type& drop_delims,
+                               const string_type& keep_delims,
+                               const string_type& quotes,
+                               const string_type& escapes)
+{
+    std::vector<string_type> tokens;
+    getTokens(instr, tokens, drop_delims, keep_delims, quotes, escapes);
+    return tokens;
 }
 
 namespace LLStringUtilBaseImpl
@@ -979,62 +979,62 @@ namespace LLStringUtilBaseImpl
 template <class T>
 struct InString
 {
-	typedef std::basic_string<T> string_type;
-	typedef typename string_type::const_iterator const_iterator;
-
-	InString(const_iterator b, const_iterator e):
-		mIter(b),
-		mEnd(e)
-	{}
-	virtual ~InString() {}
-
-	bool done() const { return mIter == mEnd; }
-	/// Is the current character (*mIter) escaped? This implementation can
-	/// answer trivially because it doesn't support escapes.
-	virtual bool escaped() const { return false; }
-	/// Obtain the current character and advance @c mIter.
-	virtual T next() { return *mIter++; }
-	/// Does the current character match specified character?
-	virtual bool is(T ch) const { return (! done()) && *mIter == ch; }
-	/// Is the current character any one of the specified characters?
-	virtual bool oneof(const string_type& delims) const
-	{
-		return (! done()) && LLStringUtilBase<T>::contains(delims, *mIter);
-	}
-
-	/**
-	 * Scan forward from @from until either @a delim or end. This is primarily
-	 * useful for processing quoted substrings.
-	 *
-	 * If we do see @a delim, append everything from @from until (excluding)
-	 * @a delim to @a into, advance @c mIter to skip @a delim, and return @c
-	 * true.
-	 *
-	 * If we do not see @a delim, do not alter @a into or @c mIter and return
-	 * @c false. Do not pass GO, do not collect $200.
-	 *
-	 * @note The @c false case described above implements normal getTokens()
-	 * treatment of an unmatched open quote: treat the quote character as if
-	 * escaped, that is, simply collect it as part of the current token. Other
-	 * plausible behaviors directly affect the way getTokens() deals with an
-	 * unmatched quote: e.g. throwing an exception to treat it as an error, or
-	 * assuming a close quote beyond end of string (in which case return @c
-	 * true).
-	 */
-	virtual bool collect_until(string_type& into, const_iterator from, T delim)
-	{
-		const_iterator found = std::find(from, mEnd, delim);
-		// If we didn't find delim, change nothing, just tell caller.
-		if (found == mEnd)
-			return false;
-		// Found delim! Append everything between from and found.
-		into.append(from, found);
-		// advance past delim in input
-		mIter = found + 1;
-		return true;
-	}
-
-	const_iterator mIter, mEnd;
+    typedef std::basic_string<T> string_type;
+    typedef typename string_type::const_iterator const_iterator;
+
+    InString(const_iterator b, const_iterator e):
+        mIter(b),
+        mEnd(e)
+    {}
+    virtual ~InString() {}
+
+    bool done() const { return mIter == mEnd; }
+    /// Is the current character (*mIter) escaped? This implementation can
+    /// answer trivially because it doesn't support escapes.
+    virtual bool escaped() const { return false; }
+    /// Obtain the current character and advance @c mIter.
+    virtual T next() { return *mIter++; }
+    /// Does the current character match specified character?
+    virtual bool is(T ch) const { return (! done()) && *mIter == ch; }
+    /// Is the current character any one of the specified characters?
+    virtual bool oneof(const string_type& delims) const
+    {
+        return (! done()) && LLStringUtilBase<T>::contains(delims, *mIter);
+    }
+
+    /**
+     * Scan forward from @from until either @a delim or end. This is primarily
+     * useful for processing quoted substrings.
+     *
+     * If we do see @a delim, append everything from @from until (excluding)
+     * @a delim to @a into, advance @c mIter to skip @a delim, and return @c
+     * true.
+     *
+     * If we do not see @a delim, do not alter @a into or @c mIter and return
+     * @c false. Do not pass GO, do not collect $200.
+     *
+     * @note The @c false case described above implements normal getTokens()
+     * treatment of an unmatched open quote: treat the quote character as if
+     * escaped, that is, simply collect it as part of the current token. Other
+     * plausible behaviors directly affect the way getTokens() deals with an
+     * unmatched quote: e.g. throwing an exception to treat it as an error, or
+     * assuming a close quote beyond end of string (in which case return @c
+     * true).
+     */
+    virtual bool collect_until(string_type& into, const_iterator from, T delim)
+    {
+        const_iterator found = std::find(from, mEnd, delim);
+        // If we didn't find delim, change nothing, just tell caller.
+        if (found == mEnd)
+            return false;
+        // Found delim! Append everything between from and found.
+        into.append(from, found);
+        // advance past delim in input
+        mIter = found + 1;
+        return true;
+    }
+
+    const_iterator mIter, mEnd;
 };
 
 /// InString subclass that handles escape characters
@@ -1042,177 +1042,177 @@ template <class T>
 class InEscString: public InString<T>
 {
 public:
-	typedef InString<T> super;
-	typedef typename super::string_type string_type;
-	typedef typename super::const_iterator const_iterator;
-	using super::done;
-	using super::mIter;
-	using super::mEnd;
-
-	InEscString(const_iterator b, const_iterator e, const string_type& escapes):
-		super(b, e),
-		mEscapes(escapes)
-	{
-		// Even though we've already initialized 'mIter' via our base-class
-		// constructor, set it again to check for initial escape char.
-		setiter(b);
-	}
-
-	/// This implementation uses the answer cached by setiter().
-	virtual bool escaped() const { return mIsEsc; }
-	virtual T next()
-	{
-		// If we're looking at the escape character of an escape sequence,
-		// skip that character. This is the one time we can modify 'mIter'
-		// without using setiter: for this one case we DO NOT CARE if the
-		// escaped character is itself an escape.
-		if (mIsEsc)
-			++mIter;
-		// If we were looking at an escape character, this is the escaped
-		// character; otherwise it's just the next character.
-		T result(*mIter);
-		// Advance mIter, checking for escape sequence.
-		setiter(mIter + 1);
-		return result;
-	}
-
-	virtual bool is(T ch) const
-	{
-		// Like base-class is(), except that an escaped character matches
-		// nothing.
-		return (! done()) && (! mIsEsc) && *mIter == ch;
-	}
-
-	virtual bool oneof(const string_type& delims) const
-	{
-		// Like base-class oneof(), except that an escaped character matches
-		// nothing.
-		return (! done()) && (! mIsEsc) && LLStringUtilBase<T>::contains(delims, *mIter);
-	}
-
-	virtual bool collect_until(string_type& into, const_iterator from, T delim)
-	{
-		// Deal with escapes in the characters we collect; that is, an escaped
-		// character must become just that character without the preceding
-		// escape. Collect characters in a separate string rather than
-		// directly appending to 'into' in case we do not find delim, in which
-		// case we're supposed to leave 'into' unmodified.
-		string_type collected;
-		// For scanning purposes, we're going to work directly with 'mIter'.
-		// Save its current value in case we fail to see delim.
-		const_iterator save_iter(mIter);
-		// Okay, set 'mIter', checking for escape.
-		setiter(from);
-		while (! done())
-		{
-			// If we see an unescaped delim, stop and report success.
-			if ((! mIsEsc) && *mIter == delim)
-			{
-				// Append collected chars to 'into'.
-				into.append(collected);
-				// Don't forget to advance 'mIter' past delim.
-				setiter(mIter + 1);
-				return true;
-			}
-			// We're not at end, and either we're not looking at delim or it's
-			// escaped. Collect this character and keep going.
-			collected.push_back(next());
-		}
-		// Here we hit 'mEnd' without ever seeing delim. Restore mIter and tell
-		// caller.
-		setiter(save_iter);
-		return false;
-	}
+    typedef InString<T> super;
+    typedef typename super::string_type string_type;
+    typedef typename super::const_iterator const_iterator;
+    using super::done;
+    using super::mIter;
+    using super::mEnd;
+
+    InEscString(const_iterator b, const_iterator e, const string_type& escapes):
+        super(b, e),
+        mEscapes(escapes)
+    {
+        // Even though we've already initialized 'mIter' via our base-class
+        // constructor, set it again to check for initial escape char.
+        setiter(b);
+    }
+
+    /// This implementation uses the answer cached by setiter().
+    virtual bool escaped() const { return mIsEsc; }
+    virtual T next()
+    {
+        // If we're looking at the escape character of an escape sequence,
+        // skip that character. This is the one time we can modify 'mIter'
+        // without using setiter: for this one case we DO NOT CARE if the
+        // escaped character is itself an escape.
+        if (mIsEsc)
+            ++mIter;
+        // If we were looking at an escape character, this is the escaped
+        // character; otherwise it's just the next character.
+        T result(*mIter);
+        // Advance mIter, checking for escape sequence.
+        setiter(mIter + 1);
+        return result;
+    }
+
+    virtual bool is(T ch) const
+    {
+        // Like base-class is(), except that an escaped character matches
+        // nothing.
+        return (! done()) && (! mIsEsc) && *mIter == ch;
+    }
+
+    virtual bool oneof(const string_type& delims) const
+    {
+        // Like base-class oneof(), except that an escaped character matches
+        // nothing.
+        return (! done()) && (! mIsEsc) && LLStringUtilBase<T>::contains(delims, *mIter);
+    }
+
+    virtual bool collect_until(string_type& into, const_iterator from, T delim)
+    {
+        // Deal with escapes in the characters we collect; that is, an escaped
+        // character must become just that character without the preceding
+        // escape. Collect characters in a separate string rather than
+        // directly appending to 'into' in case we do not find delim, in which
+        // case we're supposed to leave 'into' unmodified.
+        string_type collected;
+        // For scanning purposes, we're going to work directly with 'mIter'.
+        // Save its current value in case we fail to see delim.
+        const_iterator save_iter(mIter);
+        // Okay, set 'mIter', checking for escape.
+        setiter(from);
+        while (! done())
+        {
+            // If we see an unescaped delim, stop and report success.
+            if ((! mIsEsc) && *mIter == delim)
+            {
+                // Append collected chars to 'into'.
+                into.append(collected);
+                // Don't forget to advance 'mIter' past delim.
+                setiter(mIter + 1);
+                return true;
+            }
+            // We're not at end, and either we're not looking at delim or it's
+            // escaped. Collect this character and keep going.
+            collected.push_back(next());
+        }
+        // Here we hit 'mEnd' without ever seeing delim. Restore mIter and tell
+        // caller.
+        setiter(save_iter);
+        return false;
+    }
 
 private:
-	void setiter(const_iterator i)
-	{
-		mIter = i;
-
-		// Every time we change 'mIter', set 'mIsEsc' to be able to repetitively
-		// answer escaped() without having to rescan 'mEscapes'. mIsEsc caches
-		// contains(mEscapes, *mIter).
-
-		// We're looking at an escaped char if we're not already at end (that
-		// is, *mIter is even meaningful); if *mIter is in fact one of the
-		// specified escape characters; and if there's one more character
-		// following it. That is, if an escape character is the very last
-		// character of the input string, it loses its special meaning.
-		mIsEsc = (! done()) &&
-				LLStringUtilBase<T>::contains(mEscapes, *mIter) &&
-				(mIter+1) != mEnd;
-	}
-
-	const string_type mEscapes;
-	bool mIsEsc;
+    void setiter(const_iterator i)
+    {
+        mIter = i;
+
+        // Every time we change 'mIter', set 'mIsEsc' to be able to repetitively
+        // answer escaped() without having to rescan 'mEscapes'. mIsEsc caches
+        // contains(mEscapes, *mIter).
+
+        // We're looking at an escaped char if we're not already at end (that
+        // is, *mIter is even meaningful); if *mIter is in fact one of the
+        // specified escape characters; and if there's one more character
+        // following it. That is, if an escape character is the very last
+        // character of the input string, it loses its special meaning.
+        mIsEsc = (! done()) &&
+                LLStringUtilBase<T>::contains(mEscapes, *mIter) &&
+                (mIter+1) != mEnd;
+    }
+
+    const string_type mEscapes;
+    bool mIsEsc;
 };
 
 /// getTokens() implementation based on InString concept
 template <typename INSTRING, typename string_type>
 void getTokens(INSTRING& instr, std::vector<string_type>& tokens,
-			   const string_type& drop_delims, const string_type& keep_delims,
-			   const string_type& quotes)
-{
-	// There are times when we want to match either drop_delims or
-	// keep_delims. Concatenate them up front to speed things up.
-	string_type all_delims(drop_delims + keep_delims);
-	// no tokens yet
-	tokens.clear();
-
-	// try for another token
-	while (! instr.done())
-	{
-		// scan past any drop_delims
-		while (instr.oneof(drop_delims))
-		{
-			// skip this drop_delim
-			instr.next();
-			// but if that was the end of the string, done
-			if (instr.done())
-				return;
-		}
-		// found the start of another token: make a slot for it
-		tokens.push_back(string_type());
-		if (instr.oneof(keep_delims))
-		{
-			// *iter is a keep_delim, a token of exactly 1 character. Append
-			// that character to the new token and proceed.
-			tokens.back().push_back(instr.next());
-			continue;
-		}
-		// Here we have a non-delimiter token, which might consist of a mix of
-		// quoted and unquoted parts. Use bash rules for quoting: you can
-		// embed a quoted substring in the midst of an unquoted token (e.g.
-		// ~/"sub dir"/myfile.txt); you can ram two quoted substrings together
-		// to make a single token (e.g. 'He said, "'"Don't."'"'). We diverge
-		// from bash in that bash considers an unmatched quote an error. Our
-		// param signature doesn't allow for errors, so just pretend it's not
-		// a quote and embed it.
-		// At this level, keep scanning until we hit the next delimiter of
-		// either type (drop_delims or keep_delims).
-		while (! instr.oneof(all_delims))
-		{
-			// If we're looking at an open quote, search forward for
-			// a close quote, collecting characters along the way.
-			if (instr.oneof(quotes) &&
-				instr.collect_until(tokens.back(), instr.mIter+1, *instr.mIter))
-			{
-				// collect_until is cleverly designed to do exactly what we
-				// need here. No further action needed if it returns true.
-			}
-			else
-			{
-				// Either *iter isn't a quote, or there's no matching close
-				// quote: in other words, just an ordinary char. Append it to
-				// current token.
-				tokens.back().push_back(instr.next());
-			}
-			// having scanned that segment of this token, if we've reached the
-			// end of the string, we're done
-			if (instr.done())
-				return;
-		}
-	}
+               const string_type& drop_delims, const string_type& keep_delims,
+               const string_type& quotes)
+{
+    // There are times when we want to match either drop_delims or
+    // keep_delims. Concatenate them up front to speed things up.
+    string_type all_delims(drop_delims + keep_delims);
+    // no tokens yet
+    tokens.clear();
+
+    // try for another token
+    while (! instr.done())
+    {
+        // scan past any drop_delims
+        while (instr.oneof(drop_delims))
+        {
+            // skip this drop_delim
+            instr.next();
+            // but if that was the end of the string, done
+            if (instr.done())
+                return;
+        }
+        // found the start of another token: make a slot for it
+        tokens.push_back(string_type());
+        if (instr.oneof(keep_delims))
+        {
+            // *iter is a keep_delim, a token of exactly 1 character. Append
+            // that character to the new token and proceed.
+            tokens.back().push_back(instr.next());
+            continue;
+        }
+        // Here we have a non-delimiter token, which might consist of a mix of
+        // quoted and unquoted parts. Use bash rules for quoting: you can
+        // embed a quoted substring in the midst of an unquoted token (e.g.
+        // ~/"sub dir"/myfile.txt); you can ram two quoted substrings together
+        // to make a single token (e.g. 'He said, "'"Don't."'"'). We diverge
+        // from bash in that bash considers an unmatched quote an error. Our
+        // param signature doesn't allow for errors, so just pretend it's not
+        // a quote and embed it.
+        // At this level, keep scanning until we hit the next delimiter of
+        // either type (drop_delims or keep_delims).
+        while (! instr.oneof(all_delims))
+        {
+            // If we're looking at an open quote, search forward for
+            // a close quote, collecting characters along the way.
+            if (instr.oneof(quotes) &&
+                instr.collect_until(tokens.back(), instr.mIter+1, *instr.mIter))
+            {
+                // collect_until is cleverly designed to do exactly what we
+                // need here. No further action needed if it returns true.
+            }
+            else
+            {
+                // Either *iter isn't a quote, or there's no matching close
+                // quote: in other words, just an ordinary char. Append it to
+                // current token.
+                tokens.back().push_back(instr.next());
+            }
+            // having scanned that segment of this token, if we've reached the
+            // end of the string, we're done
+            if (instr.done())
+                return;
+        }
+    }
 }
 
 } // namespace LLStringUtilBaseImpl
@@ -1220,256 +1220,256 @@ void getTokens(INSTRING& instr, std::vector<string_type>& tokens,
 // static
 template <class T>
 void LLStringUtilBase<T>::getTokens(const string_type& string, std::vector<string_type>& tokens,
-									const string_type& drop_delims, const string_type& keep_delims,
-									const string_type& quotes)
+                                    const string_type& drop_delims, const string_type& keep_delims,
+                                    const string_type& quotes)
 {
-	// Because this overload doesn't support escapes, use simple InString to
-	// manage input range.
-	LLStringUtilBaseImpl::InString<T> instring(string.begin(), string.end());
-	LLStringUtilBaseImpl::getTokens(instring, tokens, drop_delims, keep_delims, quotes);
+    // Because this overload doesn't support escapes, use simple InString to
+    // manage input range.
+    LLStringUtilBaseImpl::InString<T> instring(string.begin(), string.end());
+    LLStringUtilBaseImpl::getTokens(instring, tokens, drop_delims, keep_delims, quotes);
 }
 
 // static
 template <class T>
 void LLStringUtilBase<T>::getTokens(const string_type& string, std::vector<string_type>& tokens,
-									const string_type& drop_delims, const string_type& keep_delims,
-									const string_type& quotes, const string_type& escapes)
-{
-	// This overload must deal with escapes. Delegate that to InEscString
-	// (unless there ARE no escapes).
-	std::unique_ptr< LLStringUtilBaseImpl::InString<T> > instrp;
-	if (escapes.empty())
-		instrp.reset(new LLStringUtilBaseImpl::InString<T>(string.begin(), string.end()));
-	else
-		instrp.reset(new LLStringUtilBaseImpl::InEscString<T>(string.begin(), string.end(), escapes));
-	LLStringUtilBaseImpl::getTokens(*instrp, tokens, drop_delims, keep_delims, quotes);
+                                    const string_type& drop_delims, const string_type& keep_delims,
+                                    const string_type& quotes, const string_type& escapes)
+{
+    // This overload must deal with escapes. Delegate that to InEscString
+    // (unless there ARE no escapes).
+    std::unique_ptr< LLStringUtilBaseImpl::InString<T> > instrp;
+    if (escapes.empty())
+        instrp.reset(new LLStringUtilBaseImpl::InString<T>(string.begin(), string.end()));
+    else
+        instrp.reset(new LLStringUtilBaseImpl::InEscString<T>(string.begin(), string.end(), escapes));
+    LLStringUtilBaseImpl::getTokens(*instrp, tokens, drop_delims, keep_delims, quotes);
 }
 
 // static
-template<class T> 
+template<class T>
 S32 LLStringUtilBase<T>::compareStrings(const T* lhs, const T* rhs)
-{	
-	S32 result;
-	if( lhs == rhs )
-	{
-		result = 0;
-	}
-	else
-	if ( !lhs || !lhs[0] )
-	{
-		result = ((!rhs || !rhs[0]) ? 0 : 1);
-	}
-	else
-	if ( !rhs || !rhs[0])
-	{
-		result = -1;
-	}
-	else
-	{
-		result = LLStringOps::collate(lhs, rhs);
-	}
-	return result;
+{
+    S32 result;
+    if( lhs == rhs )
+    {
+        result = 0;
+    }
+    else
+    if ( !lhs || !lhs[0] )
+    {
+        result = ((!rhs || !rhs[0]) ? 0 : 1);
+    }
+    else
+    if ( !rhs || !rhs[0])
+    {
+        result = -1;
+    }
+    else
+    {
+        result = LLStringOps::collate(lhs, rhs);
+    }
+    return result;
 }
 
-//static 
-template<class T> 
+//static
+template<class T>
 S32 LLStringUtilBase<T>::compareStrings(const string_type& lhs, const string_type& rhs)
 {
-	return LLStringOps::collate(lhs.c_str(), rhs.c_str());
+    return LLStringOps::collate(lhs.c_str(), rhs.c_str());
 }
 
 // static
-template<class T> 
+template<class T>
 S32 LLStringUtilBase<T>::compareInsensitive(const T* lhs, const T* rhs )
 {
-	S32 result;
-	if( lhs == rhs )
-	{
-		result = 0;
-	}
-	else
-	if ( !lhs || !lhs[0] )
-	{
-		result = ((!rhs || !rhs[0]) ? 0 : 1);
-	}
-	else
-	if ( !rhs || !rhs[0] )
-	{
-		result = -1;
-	}
-	else
-	{
-		string_type lhs_string(lhs);
-		string_type rhs_string(rhs);
-		LLStringUtilBase<T>::toUpper(lhs_string);
-		LLStringUtilBase<T>::toUpper(rhs_string);
-		result = LLStringOps::collate(lhs_string.c_str(), rhs_string.c_str());
-	}
-	return result;
+    S32 result;
+    if( lhs == rhs )
+    {
+        result = 0;
+    }
+    else
+    if ( !lhs || !lhs[0] )
+    {
+        result = ((!rhs || !rhs[0]) ? 0 : 1);
+    }
+    else
+    if ( !rhs || !rhs[0] )
+    {
+        result = -1;
+    }
+    else
+    {
+        string_type lhs_string(lhs);
+        string_type rhs_string(rhs);
+        LLStringUtilBase<T>::toUpper(lhs_string);
+        LLStringUtilBase<T>::toUpper(rhs_string);
+        result = LLStringOps::collate(lhs_string.c_str(), rhs_string.c_str());
+    }
+    return result;
 }
 
-//static 
-template<class T> 
+//static
+template<class T>
 S32 LLStringUtilBase<T>::compareInsensitive(const string_type& lhs, const string_type& rhs)
 {
-	string_type lhs_string(lhs);
-	string_type rhs_string(rhs);
-	LLStringUtilBase<T>::toUpper(lhs_string);
-	LLStringUtilBase<T>::toUpper(rhs_string);
-	return LLStringOps::collate(lhs_string.c_str(), rhs_string.c_str());
+    string_type lhs_string(lhs);
+    string_type rhs_string(rhs);
+    LLStringUtilBase<T>::toUpper(lhs_string);
+    LLStringUtilBase<T>::toUpper(rhs_string);
+    return LLStringOps::collate(lhs_string.c_str(), rhs_string.c_str());
 }
 
 // Case sensitive comparison with good handling of numbers.  Does not use current locale.
 // a.k.a. strdictcmp()
 
-//static 
+//static
 template<class T>
 S32 LLStringUtilBase<T>::compareDict(const string_type& astr, const string_type& bstr)
 {
-	const T* a = astr.c_str();
-	const T* b = bstr.c_str();
-	T ca, cb;
-	S32 ai, bi, cnt = 0;
-	S32 bias = 0;
-
-	ca = *(a++);
-	cb = *(b++);
-	while( ca && cb ){
-		if( bias==0 ){
-			if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); bias--; }
-			if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); bias++; }
-		}else{
-			if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); }
-			if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); }
-		}
-		if( LLStringOps::isDigit(ca) ){
-			if( cnt-->0 ){
-				if( cb!=ca ) break;
-			}else{
-				if( !LLStringOps::isDigit(cb) ) break;
-				for(ai=0; LLStringOps::isDigit(a[ai]); ai++);
-				for(bi=0; LLStringOps::isDigit(b[bi]); bi++);
-				if( ai<bi ){ ca=0; break; }
-				if( bi<ai ){ cb=0; break; }
-				if( ca!=cb ) break;
-				cnt = ai;
-			}
-		}else if( ca!=cb ){   break;
-		}
-		ca = *(a++);
-		cb = *(b++);
-	}
-	if( ca==cb ) ca += bias;
-	return ca-cb;
+    const T* a = astr.c_str();
+    const T* b = bstr.c_str();
+    T ca, cb;
+    S32 ai, bi, cnt = 0;
+    S32 bias = 0;
+
+    ca = *(a++);
+    cb = *(b++);
+    while( ca && cb ){
+        if( bias==0 ){
+            if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); bias--; }
+            if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); bias++; }
+        }else{
+            if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); }
+            if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); }
+        }
+        if( LLStringOps::isDigit(ca) ){
+            if( cnt-->0 ){
+                if( cb!=ca ) break;
+            }else{
+                if( !LLStringOps::isDigit(cb) ) break;
+                for(ai=0; LLStringOps::isDigit(a[ai]); ai++);
+                for(bi=0; LLStringOps::isDigit(b[bi]); bi++);
+                if( ai<bi ){ ca=0; break; }
+                if( bi<ai ){ cb=0; break; }
+                if( ca!=cb ) break;
+                cnt = ai;
+            }
+        }else if( ca!=cb ){   break;
+        }
+        ca = *(a++);
+        cb = *(b++);
+    }
+    if( ca==cb ) ca += bias;
+    return ca-cb;
 }
 
 // static
 template<class T>
 S32 LLStringUtilBase<T>::compareDictInsensitive(const string_type& astr, const string_type& bstr)
 {
-	const T* a = astr.c_str();
-	const T* b = bstr.c_str();
-	T ca, cb;
-	S32 ai, bi, cnt = 0;
-
-	ca = *(a++);
-	cb = *(b++);
-	while( ca && cb ){
-		if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); }
-		if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); }
-		if( LLStringOps::isDigit(ca) ){
-			if( cnt-->0 ){
-				if( cb!=ca ) break;
-			}else{
-				if( !LLStringOps::isDigit(cb) ) break;
-				for(ai=0; LLStringOps::isDigit(a[ai]); ai++);
-				for(bi=0; LLStringOps::isDigit(b[bi]); bi++);
-				if( ai<bi ){ ca=0; break; }
-				if( bi<ai ){ cb=0; break; }
-				if( ca!=cb ) break;
-				cnt = ai;
-			}
-		}else if( ca!=cb ){   break;
-		}
-		ca = *(a++);
-		cb = *(b++);
-	}
-	return ca-cb;
+    const T* a = astr.c_str();
+    const T* b = bstr.c_str();
+    T ca, cb;
+    S32 ai, bi, cnt = 0;
+
+    ca = *(a++);
+    cb = *(b++);
+    while( ca && cb ){
+        if( LLStringOps::isUpper(ca) ){ ca = LLStringOps::toLower(ca); }
+        if( LLStringOps::isUpper(cb) ){ cb = LLStringOps::toLower(cb); }
+        if( LLStringOps::isDigit(ca) ){
+            if( cnt-->0 ){
+                if( cb!=ca ) break;
+            }else{
+                if( !LLStringOps::isDigit(cb) ) break;
+                for(ai=0; LLStringOps::isDigit(a[ai]); ai++);
+                for(bi=0; LLStringOps::isDigit(b[bi]); bi++);
+                if( ai<bi ){ ca=0; break; }
+                if( bi<ai ){ cb=0; break; }
+                if( ca!=cb ) break;
+                cnt = ai;
+            }
+        }else if( ca!=cb ){   break;
+        }
+        ca = *(a++);
+        cb = *(b++);
+    }
+    return ca-cb;
 }
 
 // Puts compareDict() in a form appropriate for LL container classes to use for sorting.
-// static 
-template<class T> 
+// static
+template<class T>
 BOOL LLStringUtilBase<T>::precedesDict( const string_type& a, const string_type& b )
 {
-	if( a.size() && b.size() )
-	{
-		return (LLStringUtilBase<T>::compareDict(a.c_str(), b.c_str()) < 0);
-	}
-	else
-	{
-		return (!b.empty());
-	}
+    if( a.size() && b.size() )
+    {
+        return (LLStringUtilBase<T>::compareDict(a.c_str(), b.c_str()) < 0);
+    }
+    else
+    {
+        return (!b.empty());
+    }
 }
 
 //static
-template<class T> 
-void LLStringUtilBase<T>::toUpper(string_type& string)	
-{ 
-	if( !string.empty() )
-	{ 
-		std::transform(
-			string.begin(),
-			string.end(),
-			string.begin(),
-			(T(*)(T)) &LLStringOps::toUpper);
-	}
+template<class T>
+void LLStringUtilBase<T>::toUpper(string_type& string)
+{
+    if( !string.empty() )
+    {
+        std::transform(
+            string.begin(),
+            string.end(),
+            string.begin(),
+            (T(*)(T)) &LLStringOps::toUpper);
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::toLower(string_type& string)
-{ 
-	if( !string.empty() )
-	{ 
-		std::transform(
-			string.begin(),
-			string.end(),
-			string.begin(),
-			(T(*)(T)) &LLStringOps::toLower);
-	}
+{
+    if( !string.empty() )
+    {
+        std::transform(
+            string.begin(),
+            string.end(),
+            string.begin(),
+            (T(*)(T)) &LLStringOps::toLower);
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::trimHead(string_type& string)
-{			
-	if( !string.empty() )
-	{
-		size_type i = 0;
-		while( i < string.length() && LLStringOps::isSpace( string[i] ) )
-		{
-			i++;
-		}
-		string.erase(0, i);
-	}
+{
+    if( !string.empty() )
+    {
+        size_type i = 0;
+        while( i < string.length() && LLStringOps::isSpace( string[i] ) )
+        {
+            i++;
+        }
+        string.erase(0, i);
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::trimTail(string_type& string)
-{			
-	if( string.size() )
-	{
-		size_type len = string.length();
-		size_type i = len;
-		while( i > 0 && LLStringOps::isSpace( string[i-1] ) )
-		{
-			i--;
-		}
-
-		string.erase( i, len - i );
-	}
+{
+    if( string.size() )
+    {
+        size_type len = string.length();
+        size_type i = len;
+        while( i > 0 && LLStringOps::isSpace( string[i-1] ) )
+        {
+            i--;
+        }
+
+        string.erase( i, len - i );
+    }
 }
 
 
@@ -1478,67 +1478,67 @@ void LLStringUtilBase<T>::trimTail(string_type& string)
 template<class T>
 void LLStringUtilBase<T>::addCRLF(string_type& string)
 {
-	const T LF = 10;
-	const T CR = 13;
-
-	// Count the number of line feeds
-	size_type count = 0;
-	size_type len = string.size();
-	size_type i;
-	for( i = 0; i < len; i++ )
-	{
-		if( string[i] == LF )
-		{
-			count++;
-		}
-	}
-
-	// Insert a carriage return before each line feed
-	if( count )
-	{
-		size_type size = len + count;
-		T *t = new T[size];
-		size_type j = 0;
-		for( i = 0; i < len; ++i )
-		{
-			if( string[i] == LF )
-			{
-				t[j] = CR;
-				++j;
-			}
-			t[j] = string[i];
-			++j;
-		}
-
-		string.assign(t, size);
-		delete[] t;
-	}
+    const T LF = 10;
+    const T CR = 13;
+
+    // Count the number of line feeds
+    size_type count = 0;
+    size_type len = string.size();
+    size_type i;
+    for( i = 0; i < len; i++ )
+    {
+        if( string[i] == LF )
+        {
+            count++;
+        }
+    }
+
+    // Insert a carriage return before each line feed
+    if( count )
+    {
+        size_type size = len + count;
+        T *t = new T[size];
+        size_type j = 0;
+        for( i = 0; i < len; ++i )
+        {
+            if( string[i] == LF )
+            {
+                t[j] = CR;
+                ++j;
+            }
+            t[j] = string[i];
+            ++j;
+        }
+
+        string.assign(t, size);
+        delete[] t;
+    }
 }
 
 // Remove all carriage returns
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::removeCRLF(string_type& string)
 {
-	const T CR = 13;
-
-	size_type cr_count = 0;
-	size_type len = string.size();
-	size_type i;
-	for( i = 0; i < len - cr_count; i++ )
-	{
-		if( string[i+cr_count] == CR )
-		{
-			cr_count++;
-		}
-
-		string[i] = string[i+cr_count];
-	}
-	string.erase(i, cr_count);
+    const T CR = 13;
+
+    size_type cr_count = 0;
+    size_type len = string.size();
+    size_type i;
+    for( i = 0; i < len - cr_count; i++ )
+    {
+        if( string[i+cr_count] == CR )
+        {
+            cr_count++;
+        }
+
+        string[i] = string[i+cr_count];
+    }
+    string.erase(i, cr_count);
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::removeWindowsCR(string_type& string)
 {
     if (string.empty())
@@ -1567,269 +1567,269 @@ void LLStringUtilBase<T>::removeWindowsCR(string_type& string)
 template<class T>
 void LLStringUtilBase<T>::replaceChar( string_type& string, T target, T replacement )
 {
-	size_type found_pos = 0;
-	while( (found_pos = string.find(target, found_pos)) != string_type::npos ) 
-	{
-		string[found_pos] = replacement;
-		found_pos++; // avoid infinite defeat if target == replacement
-	}
+    size_type found_pos = 0;
+    while( (found_pos = string.find(target, found_pos)) != string_type::npos )
+    {
+        string[found_pos] = replacement;
+        found_pos++; // avoid infinite defeat if target == replacement
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::replaceString( string_type& string, string_type target, string_type replacement )
 {
-	size_type found_pos = 0;
-	while( (found_pos = string.find(target, found_pos)) != string_type::npos )
-	{
-		string.replace( found_pos, target.length(), replacement );
-		found_pos += replacement.length(); // avoid infinite defeat if replacement contains target
-	}
+    size_type found_pos = 0;
+    while( (found_pos = string.find(target, found_pos)) != string_type::npos )
+    {
+        string.replace( found_pos, target.length(), replacement );
+        found_pos += replacement.length(); // avoid infinite defeat if replacement contains target
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::replaceNonstandardASCII( string_type& string, T replacement )
 {
-	const char LF = 10;
-	const S8 MIN = 32;
-//	const S8 MAX = 127;
-
-	size_type len = string.size();
-	for( size_type i = 0; i < len; i++ )
-	{
-		// No need to test MAX < mText[i] because we treat mText[i] as a signed char,
-		// which has a max value of 127.
-		if( ( S8(string[i]) < MIN ) && (string[i] != LF) )
-		{
-			string[i] = replacement;
-		}
-	}
+    const char LF = 10;
+    const S8 MIN = 32;
+//  const S8 MAX = 127;
+
+    size_type len = string.size();
+    for( size_type i = 0; i < len; i++ )
+    {
+        // No need to test MAX < mText[i] because we treat mText[i] as a signed char,
+        // which has a max value of 127.
+        if( ( S8(string[i]) < MIN ) && (string[i] != LF) )
+        {
+            string[i] = replacement;
+        }
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::replaceTabsWithSpaces( string_type& str, size_type spaces_per_tab )
 {
-	const T TAB = '\t';
-	const T SPACE = ' ';
-
-	string_type out_str;
-	// Replace tabs with spaces
-	for (size_type i = 0; i < str.length(); i++)
-	{
-		if (str[i] == TAB)
-		{
-			for (size_type j = 0; j < spaces_per_tab; j++)
-				out_str += SPACE;
-		}
-		else
-		{
-			out_str += str[i];
-		}
-	}
-	str = out_str;
+    const T TAB = '\t';
+    const T SPACE = ' ';
+
+    string_type out_str;
+    // Replace tabs with spaces
+    for (size_type i = 0; i < str.length(); i++)
+    {
+        if (str[i] == TAB)
+        {
+            for (size_type j = 0; j < spaces_per_tab; j++)
+                out_str += SPACE;
+        }
+        else
+        {
+            out_str += str[i];
+        }
+    }
+    str = out_str;
 }
 
 //static
 template<class T>
 std::basic_string<T> LLStringUtilBase<T>::capitalize(const string_type& str)
 {
-	string_type result(str);
-	capitalize(result);
-	return result;
+    string_type result(str);
+    capitalize(result);
+    return result;
 }
 
 //static
 template<class T>
 void LLStringUtilBase<T>::capitalize(string_type& str)
 {
-	if (str.size())
-	{
-		auto last = str[0] = toupper(str[0]);
-		for (U32 i = 1; i < str.size(); ++i)
-		{
-			last = (last == ' ' || last == '-' || last == '_') ? str[i] = toupper(str[i]) : str[i];
-		}
-	}
+    if (str.size())
+    {
+        auto last = str[0] = toupper(str[0]);
+        for (U32 i = 1; i < str.size(); ++i)
+        {
+            last = (last == ' ' || last == '-' || last == '_') ? str[i] = toupper(str[i]) : str[i];
+        }
+    }
 }
 
 //static
-template<class T> 
+template<class T>
 BOOL LLStringUtilBase<T>::containsNonprintable(const string_type& string)
 {
-	const char MIN = 32;
-	BOOL rv = FALSE;
-	for (size_type i = 0; i < string.size(); i++)
-	{
-		if(string[i] < MIN)
-		{
-			rv = TRUE;
-			break;
-		}
-	}
-	return rv;
+    const char MIN = 32;
+    BOOL rv = FALSE;
+    for (size_type i = 0; i < string.size(); i++)
+    {
+        if(string[i] < MIN)
+        {
+            rv = TRUE;
+            break;
+        }
+    }
+    return rv;
 }
 
-// *TODO: reimplement in terms of algorithm 
+// *TODO: reimplement in terms of algorithm
 //static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::stripNonprintable(string_type& string)
 {
-	const char MIN = 32;
-	size_type j = 0;
-	if (string.empty())
-	{
-		return;
-	}
-	size_t src_size = string.size();
-	char* c_string = new char[src_size + 1];
-	if(c_string == NULL)
-	{
-		return;
-	}
-	copy(c_string, string.c_str(), src_size+1);
-	char* write_head = &c_string[0];
-	for (size_type i = 0; i < src_size; i++)
-	{
-		char* read_head = &string[i];
-		write_head = &c_string[j];
-		if(!(*read_head < MIN))
-		{
-			*write_head = *read_head;
-			++j;
-		}
-	}
-	c_string[j]= '\0';
-	string = c_string;
-	delete []c_string;
+    const char MIN = 32;
+    size_type j = 0;
+    if (string.empty())
+    {
+        return;
+    }
+    size_t src_size = string.size();
+    char* c_string = new char[src_size + 1];
+    if(c_string == NULL)
+    {
+        return;
+    }
+    copy(c_string, string.c_str(), src_size+1);
+    char* write_head = &c_string[0];
+    for (size_type i = 0; i < src_size; i++)
+    {
+        char* read_head = &string[i];
+        write_head = &c_string[j];
+        if(!(*read_head < MIN))
+        {
+            *write_head = *read_head;
+            ++j;
+        }
+    }
+    c_string[j]= '\0';
+    string = c_string;
+    delete []c_string;
 }
 
-// *TODO: reimplement in terms of algorithm 
+// *TODO: reimplement in terms of algorithm
 template<class T>
 std::basic_string<T> LLStringUtilBase<T>::quote(const string_type& str,
-												const string_type& triggers,
-												const string_type& escape)
-{
-	size_type len(str.length());
-	// If the string is already quoted, assume user knows what s/he's doing.
-	if (len >= 2 && str[0] == '"' && str[len-1] == '"')
-	{
-		return str;
-	}
-
-	// Not already quoted: do we need to? triggers.empty() is a special case
-	// meaning "always quote."
-	if ((! triggers.empty()) && str.find_first_of(triggers) == string_type::npos)
-	{
-		// no trigger characters, don't bother quoting
-		return str;
-	}
-
-	// For whatever reason, we must quote this string.
-	string_type result;
-	result.push_back('"');
-	for (typename string_type::const_iterator ci(str.begin()), cend(str.end()); ci != cend; ++ci)
-	{
-		if (*ci == '"')
-		{
-			result.append(escape);
-		}
-		result.push_back(*ci);
-	}
-	result.push_back('"');
-	return result;
+                                                const string_type& triggers,
+                                                const string_type& escape)
+{
+    size_type len(str.length());
+    // If the string is already quoted, assume user knows what s/he's doing.
+    if (len >= 2 && str[0] == '"' && str[len-1] == '"')
+    {
+        return str;
+    }
+
+    // Not already quoted: do we need to? triggers.empty() is a special case
+    // meaning "always quote."
+    if ((! triggers.empty()) && str.find_first_of(triggers) == string_type::npos)
+    {
+        // no trigger characters, don't bother quoting
+        return str;
+    }
+
+    // For whatever reason, we must quote this string.
+    string_type result;
+    result.push_back('"');
+    for (typename string_type::const_iterator ci(str.begin()), cend(str.end()); ci != cend; ++ci)
+    {
+        if (*ci == '"')
+        {
+            result.append(escape);
+        }
+        result.push_back(*ci);
+    }
+    result.push_back('"');
+    return result;
 }
 
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::_makeASCII(string_type& string)
 {
-	// Replace non-ASCII chars with LL_UNKNOWN_CHAR
-	for (size_type i = 0; i < string.length(); i++)
-	{
-		if (string[i] > 0x7f)
-		{
-			string[i] = LL_UNKNOWN_CHAR;
-		}
-	}
+    // Replace non-ASCII chars with LL_UNKNOWN_CHAR
+    for (size_type i = 0; i < string.length(); i++)
+    {
+        if (string[i] > 0x7f)
+        {
+            string[i] = LL_UNKNOWN_CHAR;
+        }
+    }
 }
 
 // static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::copy( T* dst, const T* src, size_type dst_size )
 {
-	if( dst_size > 0 )
-	{
-		size_type min_len = 0;
-		if( src )
-		{
-			min_len = llmin( dst_size - 1, strlen( src ) );  /* Flawfinder: ignore */
-			memcpy(dst, src, min_len * sizeof(T));		/* Flawfinder: ignore */
-		}
-		dst[min_len] = '\0';
-	}
+    if( dst_size > 0 )
+    {
+        size_type min_len = 0;
+        if( src )
+        {
+            min_len = llmin( dst_size - 1, strlen( src ) );  /* Flawfinder: ignore */
+            memcpy(dst, src, min_len * sizeof(T));      /* Flawfinder: ignore */
+        }
+        dst[min_len] = '\0';
+    }
 }
 
 // static
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::copyInto(string_type& dst, const string_type& src, size_type offset)
 {
-	if ( offset == dst.length() )
-	{
-		// special case - append to end of string and avoid expensive
-		// (when strings are large) string manipulations
-		dst += src;
-	}
-	else
-	{
-		string_type tail = dst.substr(offset);
-
-		dst = dst.substr(0, offset);
-		dst += src;
-		dst += tail;
-	};
+    if ( offset == dst.length() )
+    {
+        // special case - append to end of string and avoid expensive
+        // (when strings are large) string manipulations
+        dst += src;
+    }
+    else
+    {
+        string_type tail = dst.substr(offset);
+
+        dst = dst.substr(0, offset);
+        dst += src;
+        dst += tail;
+    };
 }
 
 // True if this is the head of s.
 //static
-template<class T> 
-BOOL LLStringUtilBase<T>::isHead( const string_type& string, const T* s ) 
-{ 
-	if( string.empty() )
-	{
-		// Early exit
-		return FALSE;
-	}
-	else
-	{
-		return (strncmp( s, string.c_str(), string.size() ) == 0);
-	}
+template<class T>
+BOOL LLStringUtilBase<T>::isHead( const string_type& string, const T* s )
+{
+    if( string.empty() )
+    {
+        // Early exit
+        return FALSE;
+    }
+    else
+    {
+        return (strncmp( s, string.c_str(), string.size() ) == 0);
+    }
 }
 
 // static
-template<class T> 
+template<class T>
 bool LLStringUtilBase<T>::startsWith(
-	const string_type& string,
-	const string_type& substr)
+    const string_type& string,
+    const string_type& substr)
 {
-	if(string.empty() || (substr.empty())) return false;
-	if (substr.length() > string.length()) return false;
-	if (0 == string.compare(0, substr.length(), substr)) return true;
-	return false;
+    if(string.empty() || (substr.empty())) return false;
+    if (substr.length() > string.length()) return false;
+    if (0 == string.compare(0, substr.length(), substr)) return true;
+    return false;
 }
 
 // static
-template<class T> 
+template<class T>
 bool LLStringUtilBase<T>::endsWith(
-	const string_type& string,
-	const string_type& substr)
-{
-	if(string.empty() || (substr.empty())) return false;
-	size_t sub_len = substr.length();
-	size_t str_len = string.length();
-	if (sub_len > str_len) return false;
-	if (0 == string.compare(str_len - sub_len, sub_len, substr)) return true;
-	return false;
+    const string_type& string,
+    const string_type& substr)
+{
+    if(string.empty() || (substr.empty())) return false;
+    size_t sub_len = substr.length();
+    size_t str_len = string.length();
+    if (sub_len > str_len) return false;
+    if (0 == string.compare(str_len - sub_len, sub_len, substr)) return true;
+    return false;
 }
 
 // static
@@ -1864,187 +1864,187 @@ auto LLStringUtilBase<T>::getenv(const std::string& key, const string_type& dflt
     }
 }
 
-template<class T> 
+template<class T>
 BOOL LLStringUtilBase<T>::convertToBOOL(const string_type& string, BOOL& value)
 {
-	if( string.empty() )
-	{
-		return FALSE;
-	}
-
-	string_type temp( string );
-	trim(temp);
-	if( 
-		(temp == "1") || 
-		(temp == "T") || 
-		(temp == "t") || 
-		(temp == "TRUE") || 
-		(temp == "true") || 
-		(temp == "True") )
-	{
-		value = TRUE;
-		return TRUE;
-	}
-	else
-	if( 
-		(temp == "0") || 
-		(temp == "F") || 
-		(temp == "f") || 
-		(temp == "FALSE") || 
-		(temp == "false") || 
-		(temp == "False") )
-	{
-		value = FALSE;
-		return TRUE;
-	}
-
-	return FALSE;
+    if( string.empty() )
+    {
+        return FALSE;
+    }
+
+    string_type temp( string );
+    trim(temp);
+    if(
+        (temp == "1") ||
+        (temp == "T") ||
+        (temp == "t") ||
+        (temp == "TRUE") ||
+        (temp == "true") ||
+        (temp == "True") )
+    {
+        value = TRUE;
+        return TRUE;
+    }
+    else
+    if(
+        (temp == "0") ||
+        (temp == "F") ||
+        (temp == "f") ||
+        (temp == "FALSE") ||
+        (temp == "false") ||
+        (temp == "False") )
+    {
+        value = FALSE;
+        return TRUE;
+    }
+
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToU8(const string_type& string, U8& value) 
-{
-	S32 value32 = 0;
-	BOOL success = convertToS32(string, value32);
-	if( success && (U8_MIN <= value32) && (value32 <= U8_MAX) )
-	{
-		value = (U8) value32;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToU8(const string_type& string, U8& value)
+{
+    S32 value32 = 0;
+    BOOL success = convertToS32(string, value32);
+    if( success && (U8_MIN <= value32) && (value32 <= U8_MAX) )
+    {
+        value = (U8) value32;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToS8(const string_type& string, S8& value) 
-{
-	S32 value32 = 0;
-	BOOL success = convertToS32(string, value32);
-	if( success && (S8_MIN <= value32) && (value32 <= S8_MAX) )
-	{
-		value = (S8) value32;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToS8(const string_type& string, S8& value)
+{
+    S32 value32 = 0;
+    BOOL success = convertToS32(string, value32);
+    if( success && (S8_MIN <= value32) && (value32 <= S8_MAX) )
+    {
+        value = (S8) value32;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToS16(const string_type& string, S16& value) 
-{
-	S32 value32 = 0;
-	BOOL success = convertToS32(string, value32);
-	if( success && (S16_MIN <= value32) && (value32 <= S16_MAX) )
-	{
-		value = (S16) value32;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToS16(const string_type& string, S16& value)
+{
+    S32 value32 = 0;
+    BOOL success = convertToS32(string, value32);
+    if( success && (S16_MIN <= value32) && (value32 <= S16_MAX) )
+    {
+        value = (S16) value32;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToU16(const string_type& string, U16& value) 
-{
-	S32 value32 = 0;
-	BOOL success = convertToS32(string, value32);
-	if( success && (U16_MIN <= value32) && (value32 <= U16_MAX) )
-	{
-		value = (U16) value32;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToU16(const string_type& string, U16& value)
+{
+    S32 value32 = 0;
+    BOOL success = convertToS32(string, value32);
+    if( success && (U16_MIN <= value32) && (value32 <= U16_MAX) )
+    {
+        value = (U16) value32;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToU32(const string_type& string, U32& value) 
-{
-	if( string.empty() )
-	{
-		return FALSE;
-	}
-
-	string_type temp( string );
-	trim(temp);
-	U32 v;
-	std::basic_istringstream<T> i_stream((string_type)temp);
-	if(i_stream >> v)
-	{
-		value = v;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToU32(const string_type& string, U32& value)
+{
+    if( string.empty() )
+    {
+        return FALSE;
+    }
+
+    string_type temp( string );
+    trim(temp);
+    U32 v;
+    std::basic_istringstream<T> i_stream((string_type)temp);
+    if(i_stream >> v)
+    {
+        value = v;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToS32(const string_type& string, S32& value) 
-{
-	if( string.empty() )
-	{
-		return FALSE;
-	}
-
-	string_type temp( string );
-	trim(temp);
-	S32 v;
-	std::basic_istringstream<T> i_stream((string_type)temp);
-	if(i_stream >> v)
-	{
-		//TODO: figure out overflow and underflow reporting here
-		//if((LONG_MAX == v) || (LONG_MIN == v))
-		//{
-		//	// Underflow or overflow
-		//	return FALSE;
-		//}
-
-		value = v;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToS32(const string_type& string, S32& value)
+{
+    if( string.empty() )
+    {
+        return FALSE;
+    }
+
+    string_type temp( string );
+    trim(temp);
+    S32 v;
+    std::basic_istringstream<T> i_stream((string_type)temp);
+    if(i_stream >> v)
+    {
+        //TODO: figure out overflow and underflow reporting here
+        //if((LONG_MAX == v) || (LONG_MIN == v))
+        //{
+        //  // Underflow or overflow
+        //  return FALSE;
+        //}
+
+        value = v;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
-BOOL LLStringUtilBase<T>::convertToF32(const string_type& string, F32& value) 
-{
-	F64 value64 = 0.0;
-	BOOL success = convertToF64(string, value64);
-	if( success && (-F32_MAX <= value64) && (value64 <= F32_MAX) )
-	{
-		value = (F32) value64;
-		return TRUE;
-	}
-	return FALSE;
+template<class T>
+BOOL LLStringUtilBase<T>::convertToF32(const string_type& string, F32& value)
+{
+    F64 value64 = 0.0;
+    BOOL success = convertToF64(string, value64);
+    if( success && (-F32_MAX <= value64) && (value64 <= F32_MAX) )
+    {
+        value = (F32) value64;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
+template<class T>
 BOOL LLStringUtilBase<T>::convertToF64(const string_type& string, F64& value)
 {
-	if( string.empty() )
-	{
-		return FALSE;
-	}
-
-	string_type temp( string );
-	trim(temp);
-	F64 v;
-	std::basic_istringstream<T> i_stream((string_type)temp);
-	if(i_stream >> v)
-	{
-		//TODO: figure out overflow and underflow reporting here
-		//if( ((-HUGE_VAL == v) || (HUGE_VAL == v))) )
-		//{
-		//	// Underflow or overflow
-		//	return FALSE;
-		//}
-
-		value = v;
-		return TRUE;
-	}
-	return FALSE;
+    if( string.empty() )
+    {
+        return FALSE;
+    }
+
+    string_type temp( string );
+    trim(temp);
+    F64 v;
+    std::basic_istringstream<T> i_stream((string_type)temp);
+    if(i_stream >> v)
+    {
+        //TODO: figure out overflow and underflow reporting here
+        //if( ((-HUGE_VAL == v) || (HUGE_VAL == v))) )
+        //{
+        //  // Underflow or overflow
+        //  return FALSE;
+        //}
+
+        value = v;
+        return TRUE;
+    }
+    return FALSE;
 }
 
-template<class T> 
+template<class T>
 void LLStringUtilBase<T>::truncate(string_type& string, size_type count)
 {
-	size_type cur_size = string.size();
-	string.resize(count < cur_size ? count : cur_size);
+    size_type cur_size = string.size();
+    string.resize(count < cur_size ? count : cur_size);
 }
 
 // The good thing about *declaration* macros, vs. usage macros, is that now
diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp
index 730731a927..6e15e80ef3 100644
--- a/indra/llcommon/tests/llsdserialize_test.cpp
+++ b/indra/llcommon/tests/llsdserialize_test.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llsdserialize_test.cpp
  * @date 2006-04
  * @brief LLSDSerialize unit tests
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -64,313 +64,313 @@ typedef std::function<bool(std::istream& istr, LLSD& data, llssize max_bytes)> P
 
 std::vector<U8> string_to_vector(const std::string& str)
 {
-	return std::vector<U8>(str.begin(), str.end());
+    return std::vector<U8>(str.begin(), str.end());
 }
 
 namespace tut
 {
-	struct sd_xml_data
-	{
-		sd_xml_data()
-		{
-			mFormatter = new LLSDXMLFormatter;
-		}
-		LLSD mSD;
-		LLPointer<LLSDXMLFormatter> mFormatter;
-		void xml_test(const char* name, const std::string& expected)
-		{
-			std::ostringstream ostr;
-			mFormatter->format(mSD, ostr);
-			ensure_equals(name, ostr.str(), expected);
-		}
-	};
-
-	typedef test_group<sd_xml_data> sd_xml_test;
-	typedef sd_xml_test::object sd_xml_object;
-	tut::sd_xml_test sd_xml_stream("LLSDXMLFormatter");
-
-	template<> template<>
-	void sd_xml_object::test<1>()
-	{
-		// random atomic tests
-		std::string expected;
-
-		expected = "<llsd><undef /></llsd>\n";
-		xml_test("undef", expected);
-
-		mSD = 3463;
-		expected = "<llsd><integer>3463</integer></llsd>\n";
-		xml_test("integer", expected);
-
-		mSD = "";
-		expected = "<llsd><string /></llsd>\n";
-		xml_test("empty string", expected);
-
-		mSD = "foobar";
-		expected = "<llsd><string>foobar</string></llsd>\n";
-		xml_test("string", expected);
-
-		mSD = LLUUID::null;
-		expected = "<llsd><uuid /></llsd>\n";
-		xml_test("null uuid", expected);
-
-		mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed");
-		expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>\n";
-		xml_test("uuid", expected);
-
-		mSD = LLURI("https://secondlife.com/login");
-		expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>\n";
-		xml_test("uri", expected);
-
-		mSD = LLDate("2006-04-24T16:11:33Z");
-		expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>\n";
-		xml_test("date", expected);
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		std::vector<U8> hello;
-		hello.push_back('h');
-		hello.push_back('e');
-		hello.push_back('l');
-		hello.push_back('l');
-		hello.push_back('o');
-		mSD = hello;
-		expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		xml_test("binary", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<2>()
-	{
-		// tests with boolean values.
-		std::string expected;
-
-		mFormatter->boolalpha(true);
-		mSD = true;
-		expected = "<llsd><boolean>true</boolean></llsd>\n";
-		xml_test("bool alpha true", expected);
-		mSD = false;
-		expected = "<llsd><boolean>false</boolean></llsd>\n";
-		xml_test("bool alpha false", expected);
-
-		mFormatter->boolalpha(false);
-		mSD = true;
-		expected = "<llsd><boolean>1</boolean></llsd>\n";
-		xml_test("bool true", expected);
-		mSD = false;
-		expected = "<llsd><boolean>0</boolean></llsd>\n";
-		xml_test("bool false", expected);
-	}
-
-
-	template<> template<>
-	void sd_xml_object::test<3>()
-	{
-		// tests with real values.
-		std::string expected;
-
-		mFormatter->realFormat("%.2f");
-		mSD = 1.0;
-		expected = "<llsd><real>1.00</real></llsd>\n";
-		xml_test("real 1", expected);
-
-		mSD = -34379.0438;
-		expected = "<llsd><real>-34379.04</real></llsd>\n";
-		xml_test("real reduced precision", expected);
-		mFormatter->realFormat("%.4f");
-		expected = "<llsd><real>-34379.0438</real></llsd>\n";
-		xml_test("higher precision", expected);
-
-		mFormatter->realFormat("%.0f");
-		mSD = 0.0;
-		expected = "<llsd><real>0</real></llsd>\n";
-		xml_test("no decimal 0", expected);
-		mSD = 3287.4387;
-		expected = "<llsd><real>3287</real></llsd>\n";
-		xml_test("no decimal real number", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<4>()
-	{
-		// tests with arrays
-		std::string expected;
-
-		mSD = LLSD::emptyArray();
-		expected = "<llsd><array /></llsd>\n";
-		xml_test("empty array", expected);
-
-		mSD.append(LLSD());
-		expected = "<llsd><array><undef /></array></llsd>\n";
-		xml_test("1 element array", expected);
-
-		mSD.append(1);
-		expected = "<llsd><array><undef /><integer>1</integer></array></llsd>\n";
-		xml_test("2 element array", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<5>()
-	{
-		// tests with arrays
-		std::string expected;
-
-		mSD = LLSD::emptyMap();
-		expected = "<llsd><map /></llsd>\n";
-		xml_test("empty map", expected);
-
-		mSD["foo"] = "bar";
-		expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>\n";
-		xml_test("1 element map", expected);
-
-		mSD["baz"] = LLSD();
-		expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>\n";
-		xml_test("2 element map", expected);
-	}
-
-	template<> template<>
-	void sd_xml_object::test<6>()
-	{
-		// tests with binary
-		std::string expected;
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		mSD = string_to_vector("hello");
-		expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		xml_test("binary", expected);
-
-		mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		expected = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		xml_test("binary", expected);
-	}
-
-	class TestLLSDSerializeData
-	{
-	public:
-		TestLLSDSerializeData();
-		~TestLLSDSerializeData();
-
-		void doRoundTripTests(const std::string&);
-		void checkRoundTrip(const std::string&, const LLSD& v);
-
-		void setFormatterParser(LLPointer<LLSDFormatter> formatter, LLPointer<LLSDParser> parser)
-		{
-			mFormatter = [formatter](const LLSD& data, std::ostream& str)
-			{
-				formatter->format(data, str);
-			};
-			// this lambda must be mutable since otherwise the bound 'parser'
-			// is assumed to point to a const LLSDParser
-			mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) mutable
-			{
-				// reset() call is needed since test code re-uses parser object
-				parser->reset();
-				return (parser->parse(istr, data, max_bytes) > 0);
-			};
-		}
-
-		void setParser(bool (*parser)(LLSD&, std::istream&, llssize))
-		{
-			// why does LLSDSerialize::deserialize() reverse the parse() params??
-			mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes)
-			{
-				return parser(data, istr, max_bytes);
-			};
-		}
-
-		FormatterFunction mFormatter;
-		ParserFunction mParser;
-	};
-
-	TestLLSDSerializeData::TestLLSDSerializeData()
-	{
-	}
-
-	TestLLSDSerializeData::~TestLLSDSerializeData()
-	{
-	}
-
-	void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v)
-	{
-		std::stringstream stream;
-		mFormatter(v, stream);
-		//LL_INFOS() << "checkRoundTrip: length " << stream.str().length() << LL_ENDL;
-		LLSD w;
-		mParser(stream, w, stream.str().size());
-
-		try
-		{
-			ensure_equals(msg, w, v);
-		}
-		catch (...)
-		{
-			std::cerr << "the serialized string was:" << std::endl;
-			std::cerr << stream.str() << std::endl;
-			throw;
-		}
-	}
-
-	static void fillmap(LLSD& root, U32 width, U32 depth)
-	{
-		if(depth == 0)
-		{
-			root["foo"] = "bar";
-			return;
-		}
-
-		for(U32 i = 0; i < width; ++i)
-		{
-			std::string key = llformat("child %d", i);
-			root[key] = LLSD::emptyMap();
-			fillmap(root[key], width, depth - 1);
-		}
-	}
-
-	void TestLLSDSerializeData::doRoundTripTests(const std::string& msg)
-	{
-		LLSD v;
-		checkRoundTrip(msg + " undefined", v);
-
-		v = true;
-		checkRoundTrip(msg + " true bool", v);
-
-		v = false;
-		checkRoundTrip(msg + " false bool", v);
-
-		v = 1;
-		checkRoundTrip(msg + " positive int", v);
-
-		v = 0;
-		checkRoundTrip(msg + " zero int", v);
-
-		v = -1;
-		checkRoundTrip(msg + " negative int", v);
-
-		v = 1234.5f;
-		checkRoundTrip(msg + " positive float", v);
-
-		v = 0.0f;
-		checkRoundTrip(msg + " zero float", v);
-
-		v = -1234.5f;
-		checkRoundTrip(msg + " negative float", v);
-
-		// FIXME: need a NaN test
-
-		v = LLUUID::null;
-		checkRoundTrip(msg + " null uuid", v);
-
-		LLUUID newUUID;
-		newUUID.generate();
-		v = newUUID;
-		checkRoundTrip(msg + " new uuid", v);
-
-		v = "";
-		checkRoundTrip(msg + " empty string", v);
-
-		v = "some string";
-		checkRoundTrip(msg + " non-empty string", v);
-
-		v =
+    struct sd_xml_data
+    {
+        sd_xml_data()
+        {
+            mFormatter = new LLSDXMLFormatter;
+        }
+        LLSD mSD;
+        LLPointer<LLSDXMLFormatter> mFormatter;
+        void xml_test(const char* name, const std::string& expected)
+        {
+            std::ostringstream ostr;
+            mFormatter->format(mSD, ostr);
+            ensure_equals(name, ostr.str(), expected);
+        }
+    };
+
+    typedef test_group<sd_xml_data> sd_xml_test;
+    typedef sd_xml_test::object sd_xml_object;
+    tut::sd_xml_test sd_xml_stream("LLSDXMLFormatter");
+
+    template<> template<>
+    void sd_xml_object::test<1>()
+    {
+        // random atomic tests
+        std::string expected;
+
+        expected = "<llsd><undef /></llsd>\n";
+        xml_test("undef", expected);
+
+        mSD = 3463;
+        expected = "<llsd><integer>3463</integer></llsd>\n";
+        xml_test("integer", expected);
+
+        mSD = "";
+        expected = "<llsd><string /></llsd>\n";
+        xml_test("empty string", expected);
+
+        mSD = "foobar";
+        expected = "<llsd><string>foobar</string></llsd>\n";
+        xml_test("string", expected);
+
+        mSD = LLUUID::null;
+        expected = "<llsd><uuid /></llsd>\n";
+        xml_test("null uuid", expected);
+
+        mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed");
+        expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>\n";
+        xml_test("uuid", expected);
+
+        mSD = LLURI("https://secondlife.com/login");
+        expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>\n";
+        xml_test("uri", expected);
+
+        mSD = LLDate("2006-04-24T16:11:33Z");
+        expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>\n";
+        xml_test("date", expected);
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        std::vector<U8> hello;
+        hello.push_back('h');
+        hello.push_back('e');
+        hello.push_back('l');
+        hello.push_back('l');
+        hello.push_back('o');
+        mSD = hello;
+        expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        xml_test("binary", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<2>()
+    {
+        // tests with boolean values.
+        std::string expected;
+
+        mFormatter->boolalpha(true);
+        mSD = true;
+        expected = "<llsd><boolean>true</boolean></llsd>\n";
+        xml_test("bool alpha true", expected);
+        mSD = false;
+        expected = "<llsd><boolean>false</boolean></llsd>\n";
+        xml_test("bool alpha false", expected);
+
+        mFormatter->boolalpha(false);
+        mSD = true;
+        expected = "<llsd><boolean>1</boolean></llsd>\n";
+        xml_test("bool true", expected);
+        mSD = false;
+        expected = "<llsd><boolean>0</boolean></llsd>\n";
+        xml_test("bool false", expected);
+    }
+
+
+    template<> template<>
+    void sd_xml_object::test<3>()
+    {
+        // tests with real values.
+        std::string expected;
+
+        mFormatter->realFormat("%.2f");
+        mSD = 1.0;
+        expected = "<llsd><real>1.00</real></llsd>\n";
+        xml_test("real 1", expected);
+
+        mSD = -34379.0438;
+        expected = "<llsd><real>-34379.04</real></llsd>\n";
+        xml_test("real reduced precision", expected);
+        mFormatter->realFormat("%.4f");
+        expected = "<llsd><real>-34379.0438</real></llsd>\n";
+        xml_test("higher precision", expected);
+
+        mFormatter->realFormat("%.0f");
+        mSD = 0.0;
+        expected = "<llsd><real>0</real></llsd>\n";
+        xml_test("no decimal 0", expected);
+        mSD = 3287.4387;
+        expected = "<llsd><real>3287</real></llsd>\n";
+        xml_test("no decimal real number", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<4>()
+    {
+        // tests with arrays
+        std::string expected;
+
+        mSD = LLSD::emptyArray();
+        expected = "<llsd><array /></llsd>\n";
+        xml_test("empty array", expected);
+
+        mSD.append(LLSD());
+        expected = "<llsd><array><undef /></array></llsd>\n";
+        xml_test("1 element array", expected);
+
+        mSD.append(1);
+        expected = "<llsd><array><undef /><integer>1</integer></array></llsd>\n";
+        xml_test("2 element array", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<5>()
+    {
+        // tests with arrays
+        std::string expected;
+
+        mSD = LLSD::emptyMap();
+        expected = "<llsd><map /></llsd>\n";
+        xml_test("empty map", expected);
+
+        mSD["foo"] = "bar";
+        expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>\n";
+        xml_test("1 element map", expected);
+
+        mSD["baz"] = LLSD();
+        expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>\n";
+        xml_test("2 element map", expected);
+    }
+
+    template<> template<>
+    void sd_xml_object::test<6>()
+    {
+        // tests with binary
+        std::string expected;
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        mSD = string_to_vector("hello");
+        expected = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        xml_test("binary", expected);
+
+        mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        expected = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        xml_test("binary", expected);
+    }
+
+    class TestLLSDSerializeData
+    {
+    public:
+        TestLLSDSerializeData();
+        ~TestLLSDSerializeData();
+
+        void doRoundTripTests(const std::string&);
+        void checkRoundTrip(const std::string&, const LLSD& v);
+
+        void setFormatterParser(LLPointer<LLSDFormatter> formatter, LLPointer<LLSDParser> parser)
+        {
+            mFormatter = [formatter](const LLSD& data, std::ostream& str)
+            {
+                formatter->format(data, str);
+            };
+            // this lambda must be mutable since otherwise the bound 'parser'
+            // is assumed to point to a const LLSDParser
+            mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes) mutable
+            {
+                // reset() call is needed since test code re-uses parser object
+                parser->reset();
+                return (parser->parse(istr, data, max_bytes) > 0);
+            };
+        }
+
+        void setParser(bool (*parser)(LLSD&, std::istream&, llssize))
+        {
+            // why does LLSDSerialize::deserialize() reverse the parse() params??
+            mParser = [parser](std::istream& istr, LLSD& data, llssize max_bytes)
+            {
+                return parser(data, istr, max_bytes);
+            };
+        }
+
+        FormatterFunction mFormatter;
+        ParserFunction mParser;
+    };
+
+    TestLLSDSerializeData::TestLLSDSerializeData()
+    {
+    }
+
+    TestLLSDSerializeData::~TestLLSDSerializeData()
+    {
+    }
+
+    void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v)
+    {
+        std::stringstream stream;
+        mFormatter(v, stream);
+        //LL_INFOS() << "checkRoundTrip: length " << stream.str().length() << LL_ENDL;
+        LLSD w;
+        mParser(stream, w, stream.str().size());
+
+        try
+        {
+            ensure_equals(msg, w, v);
+        }
+        catch (...)
+        {
+            std::cerr << "the serialized string was:" << std::endl;
+            std::cerr << stream.str() << std::endl;
+            throw;
+        }
+    }
+
+    static void fillmap(LLSD& root, U32 width, U32 depth)
+    {
+        if(depth == 0)
+        {
+            root["foo"] = "bar";
+            return;
+        }
+
+        for(U32 i = 0; i < width; ++i)
+        {
+            std::string key = llformat("child %d", i);
+            root[key] = LLSD::emptyMap();
+            fillmap(root[key], width, depth - 1);
+        }
+    }
+
+    void TestLLSDSerializeData::doRoundTripTests(const std::string& msg)
+    {
+        LLSD v;
+        checkRoundTrip(msg + " undefined", v);
+
+        v = true;
+        checkRoundTrip(msg + " true bool", v);
+
+        v = false;
+        checkRoundTrip(msg + " false bool", v);
+
+        v = 1;
+        checkRoundTrip(msg + " positive int", v);
+
+        v = 0;
+        checkRoundTrip(msg + " zero int", v);
+
+        v = -1;
+        checkRoundTrip(msg + " negative int", v);
+
+        v = 1234.5f;
+        checkRoundTrip(msg + " positive float", v);
+
+        v = 0.0f;
+        checkRoundTrip(msg + " zero float", v);
+
+        v = -1234.5f;
+        checkRoundTrip(msg + " negative float", v);
+
+        // FIXME: need a NaN test
+
+        v = LLUUID::null;
+        checkRoundTrip(msg + " null uuid", v);
+
+        LLUUID newUUID;
+        newUUID.generate();
+        v = newUUID;
+        checkRoundTrip(msg + " new uuid", v);
+
+        v = "";
+        checkRoundTrip(msg + " empty string", v);
+
+        v = "some string";
+        checkRoundTrip(msg + " non-empty string", v);
+
+        v =
 "Second Life is a 3-D virtual world entirely built and owned by its residents. "
 "Since opening to the public in 2003, it has grown explosively and today is "
 "inhabited by nearly 100,000 people from around the globe.\n"
@@ -390,437 +390,437 @@ namespace tut
 "currency exchanges.\n"
 "\n"
 "Welcome to Second Life. We look forward to seeing you in-world!\n"
-		;
-		checkRoundTrip(msg + " long string", v);
-
-		static const U32 block_size = 0x000020;
-		for (U32 block = 0x000000; block <= 0x10ffff; block += block_size)
-		{
-			std::ostringstream out;
-
-			for (U32 c = block; c < block + block_size; ++c)
-			{
-				if (c <= 0x000001f
-					&& c != 0x000009
-					&& c != 0x00000a)
-				{
-					// see XML standard, sections 2.2 and 4.1
-					continue;
-				}
-				if (0x00d800 <= c  &&  c <= 0x00dfff) { continue; }
-				if (0x00fdd0 <= c  &&  c <= 0x00fdef) { continue; }
-				if ((c & 0x00fffe) == 0x00fffe) { continue; }		
-					// see Unicode standard, section 15.8 
-
-				if (c <= 0x00007f)
-				{
-					out << (char)(c & 0x7f);
-				}
-				else if (c <= 0x0007ff)
-				{
-					out << (char)(0xc0 | ((c >> 6) & 0x1f));
-					out << (char)(0x80 | ((c >> 0) & 0x3f));
-				}
-				else if (c <= 0x00ffff)
-				{
-					out << (char)(0xe0 | ((c >> 12) & 0x0f));
-					out << (char)(0x80 | ((c >>  6) & 0x3f));
-					out << (char)(0x80 | ((c >>  0) & 0x3f));
-				}
-				else
-				{
-					out << (char)(0xf0 | ((c >> 18) & 0x07));
-					out << (char)(0x80 | ((c >> 12) & 0x3f));
-					out << (char)(0x80 | ((c >>  6) & 0x3f));
-					out << (char)(0x80 | ((c >>  0) & 0x3f));
-				}
-			}
-
-			v = out.str();
-
-			std::ostringstream blockmsg;
-			blockmsg << msg << " unicode string block 0x" << std::hex << block; 
-			checkRoundTrip(blockmsg.str(), v);
-		}
-
-		LLDate epoch;
-		v = epoch;
-		checkRoundTrip(msg + " epoch date", v);
-
-		LLDate aDay("2002-12-07T05:07:15.00Z");
-		v = aDay;
-		checkRoundTrip(msg + " date", v);
-
-		LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
-		v = path;
-		checkRoundTrip(msg + " url", v);
-
-		const char source[] = "it must be a blue moon again";
-		std::vector<U8> data;
-		// note, includes terminating '\0'
-		copy(&source[0], &source[sizeof(source)], back_inserter(data));
-
-		v = data;
-		checkRoundTrip(msg + " binary", v);
-
-		v = LLSD::emptyMap();
-		checkRoundTrip(msg + " empty map", v);
-
-		v = LLSD::emptyMap();
-		v["name"] = "luke";		//v.insert("name", "luke");
-		v["age"] = 3;			//v.insert("age", 3);
-		checkRoundTrip(msg + " map", v);
-
-		v.clear();
-		v["a"]["1"] = true;
-		v["b"]["0"] = false;
-		checkRoundTrip(msg + " nested maps", v);
-
-		v = LLSD::emptyArray();
-		checkRoundTrip(msg + " empty array", v);
-
-		v = LLSD::emptyArray();
-		v.append("ali");
-		v.append(28);
-		checkRoundTrip(msg + " array", v);
-
-		v.clear();
-		v[0][0] = true;
-		v[1][0] = false;
-		checkRoundTrip(msg + " nested arrays", v);
-
-		v = LLSD::emptyMap();
-		fillmap(v, 10, 3); // 10^6 maps
-		checkRoundTrip(msg + " many nested maps", v);
-	}
-
-	typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerializeGroup;
-	typedef TestLLSDSerializeGroup::object TestLLSDSerializeObject;
-	TestLLSDSerializeGroup gTestLLSDSerializeGroup("llsd serialization");
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<1>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_PRETTY_BINARY),
-						   new LLSDNotationParser());
-		doRoundTripTests("pretty binary notation serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<2>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDNotationParser());
-		doRoundTripTests("raw binary notation serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<3>()
-	{
-		setFormatterParser(new LLSDXMLFormatter(), new LLSDXMLParser());
-		doRoundTripTests("xml serialization");
-	}
-
-	template<> template<> 
-	void TestLLSDSerializeObject::test<4>()
-	{
-		setFormatterParser(new LLSDBinaryFormatter(), new LLSDBinaryParser());
-		doRoundTripTests("binary serialization");
-	}
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<5>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_BINARY);
-		};
-		setParser(LLSDSerialize::deserialize);
-		doRoundTripTests("serialize(LLSD_BINARY)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<6>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_XML);
-		};
-		setParser(LLSDSerialize::deserialize);
-		doRoundTripTests("serialize(LLSD_XML)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<7>()
-	{
-		mFormatter = [](const LLSD& sd, std::ostream& str)
-		{
-			LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_NOTATION);
-		};
-		setParser(LLSDSerialize::deserialize);
-		// In this test, serialize(LLSD_NOTATION) emits a header recognized by
-		// deserialize().
-		doRoundTripTests("serialize(LLSD_NOTATION)");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<8>()
-	{
-		setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDNotationParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDNotationFormatter does not
-		// emit an llsd/notation header.
-		doRoundTripTests("LLSDNotationFormatter -> deserialize");
-	};
-
-	template<> template<>
-	void TestLLSDSerializeObject::test<9>()
-	{
-		setFormatterParser(new LLSDXMLFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDXMLParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDXMLFormatter does not
-		// emit an LLSD/XML header.
-		doRoundTripTests("LLSDXMLFormatter -> deserialize");
-	};
+        ;
+        checkRoundTrip(msg + " long string", v);
+
+        static const U32 block_size = 0x000020;
+        for (U32 block = 0x000000; block <= 0x10ffff; block += block_size)
+        {
+            std::ostringstream out;
+
+            for (U32 c = block; c < block + block_size; ++c)
+            {
+                if (c <= 0x000001f
+                    && c != 0x000009
+                    && c != 0x00000a)
+                {
+                    // see XML standard, sections 2.2 and 4.1
+                    continue;
+                }
+                if (0x00d800 <= c  &&  c <= 0x00dfff) { continue; }
+                if (0x00fdd0 <= c  &&  c <= 0x00fdef) { continue; }
+                if ((c & 0x00fffe) == 0x00fffe) { continue; }
+                    // see Unicode standard, section 15.8
+
+                if (c <= 0x00007f)
+                {
+                    out << (char)(c & 0x7f);
+                }
+                else if (c <= 0x0007ff)
+                {
+                    out << (char)(0xc0 | ((c >> 6) & 0x1f));
+                    out << (char)(0x80 | ((c >> 0) & 0x3f));
+                }
+                else if (c <= 0x00ffff)
+                {
+                    out << (char)(0xe0 | ((c >> 12) & 0x0f));
+                    out << (char)(0x80 | ((c >>  6) & 0x3f));
+                    out << (char)(0x80 | ((c >>  0) & 0x3f));
+                }
+                else
+                {
+                    out << (char)(0xf0 | ((c >> 18) & 0x07));
+                    out << (char)(0x80 | ((c >> 12) & 0x3f));
+                    out << (char)(0x80 | ((c >>  6) & 0x3f));
+                    out << (char)(0x80 | ((c >>  0) & 0x3f));
+                }
+            }
+
+            v = out.str();
+
+            std::ostringstream blockmsg;
+            blockmsg << msg << " unicode string block 0x" << std::hex << block;
+            checkRoundTrip(blockmsg.str(), v);
+        }
+
+        LLDate epoch;
+        v = epoch;
+        checkRoundTrip(msg + " epoch date", v);
+
+        LLDate aDay("2002-12-07T05:07:15.00Z");
+        v = aDay;
+        checkRoundTrip(msg + " date", v);
+
+        LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
+        v = path;
+        checkRoundTrip(msg + " url", v);
+
+        const char source[] = "it must be a blue moon again";
+        std::vector<U8> data;
+        // note, includes terminating '\0'
+        copy(&source[0], &source[sizeof(source)], back_inserter(data));
+
+        v = data;
+        checkRoundTrip(msg + " binary", v);
+
+        v = LLSD::emptyMap();
+        checkRoundTrip(msg + " empty map", v);
+
+        v = LLSD::emptyMap();
+        v["name"] = "luke";     //v.insert("name", "luke");
+        v["age"] = 3;           //v.insert("age", 3);
+        checkRoundTrip(msg + " map", v);
+
+        v.clear();
+        v["a"]["1"] = true;
+        v["b"]["0"] = false;
+        checkRoundTrip(msg + " nested maps", v);
+
+        v = LLSD::emptyArray();
+        checkRoundTrip(msg + " empty array", v);
+
+        v = LLSD::emptyArray();
+        v.append("ali");
+        v.append(28);
+        checkRoundTrip(msg + " array", v);
+
+        v.clear();
+        v[0][0] = true;
+        v[1][0] = false;
+        checkRoundTrip(msg + " nested arrays", v);
+
+        v = LLSD::emptyMap();
+        fillmap(v, 10, 3); // 10^6 maps
+        checkRoundTrip(msg + " many nested maps", v);
+    }
+
+    typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerializeGroup;
+    typedef TestLLSDSerializeGroup::object TestLLSDSerializeObject;
+    TestLLSDSerializeGroup gTestLLSDSerializeGroup("llsd serialization");
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<1>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_PRETTY_BINARY),
+                           new LLSDNotationParser());
+        doRoundTripTests("pretty binary notation serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<2>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDNotationParser());
+        doRoundTripTests("raw binary notation serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<3>()
+    {
+        setFormatterParser(new LLSDXMLFormatter(), new LLSDXMLParser());
+        doRoundTripTests("xml serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<4>()
+    {
+        setFormatterParser(new LLSDBinaryFormatter(), new LLSDBinaryParser());
+        doRoundTripTests("binary serialization");
+    }
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<5>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_BINARY);
+        };
+        setParser(LLSDSerialize::deserialize);
+        doRoundTripTests("serialize(LLSD_BINARY)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<6>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_XML);
+        };
+        setParser(LLSDSerialize::deserialize);
+        doRoundTripTests("serialize(LLSD_XML)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<7>()
+    {
+        mFormatter = [](const LLSD& sd, std::ostream& str)
+        {
+            LLSDSerialize::serialize(sd, str, LLSDSerialize::LLSD_NOTATION);
+        };
+        setParser(LLSDSerialize::deserialize);
+        // In this test, serialize(LLSD_NOTATION) emits a header recognized by
+        // deserialize().
+        doRoundTripTests("serialize(LLSD_NOTATION)");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<8>()
+    {
+        setFormatterParser(new LLSDNotationFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDNotationParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDNotationFormatter does not
+        // emit an llsd/notation header.
+        doRoundTripTests("LLSDNotationFormatter -> deserialize");
+    };
+
+    template<> template<>
+    void TestLLSDSerializeObject::test<9>()
+    {
+        setFormatterParser(new LLSDXMLFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDXMLParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDXMLFormatter does not
+        // emit an LLSD/XML header.
+        doRoundTripTests("LLSDXMLFormatter -> deserialize");
+    };
 
 /*==========================================================================*|
-	// We do not expect this test to succeed. Without a header, neither
-	// notation LLSD nor binary LLSD reliably start with a distinct character,
-	// the way XML LLSD starts with '<'. By convention, we default to notation
-	// rather than binary.
-	template<> template<>
-	void TestLLSDSerializeObject::test<10>()
-	{
-		setFormatterParser(new LLSDBinaryFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
-						   new LLSDBinaryParser());
-		setParser(LLSDSerialize::deserialize);
-		// This is an interesting test because LLSDBinaryFormatter does not
-		// emit an LLSD/Binary header.
-		doRoundTripTests("LLSDBinaryFormatter -> deserialize");
-	};
+    // We do not expect this test to succeed. Without a header, neither
+    // notation LLSD nor binary LLSD reliably start with a distinct character,
+    // the way XML LLSD starts with '<'. By convention, we default to notation
+    // rather than binary.
+    template<> template<>
+    void TestLLSDSerializeObject::test<10>()
+    {
+        setFormatterParser(new LLSDBinaryFormatter(false, "", LLSDFormatter::OPTIONS_NONE),
+                           new LLSDBinaryParser());
+        setParser(LLSDSerialize::deserialize);
+        // This is an interesting test because LLSDBinaryFormatter does not
+        // emit an LLSD/Binary header.
+        doRoundTripTests("LLSDBinaryFormatter -> deserialize");
+    };
 |*==========================================================================*/
 
-	/**
-	 * @class TestLLSDParsing
-	 * @brief Base class for of a parse tester.
-	 */
-	template <class parser_t>
-	class TestLLSDParsing
-	{
-	public:
-		TestLLSDParsing()
-		{
-			mParser = new parser_t;
-		}
-
-		void ensureParse(
-			const std::string& msg,
-			const std::string& in,
-			const LLSD& expected_value,
-			S32 expected_count,
-			S32 depth_limit = -1)
-		{
-			std::stringstream input;
-			input.str(in);
-
-			LLSD parsed_result;
-			mParser->reset();	// reset() call is needed since test code re-uses mParser
-			S32 parsed_count = mParser->parse(input, parsed_result, in.size(), depth_limit);
-			ensure_equals(msg.c_str(), parsed_result, expected_value);
-
-			// This count check is really only useful for expected
-			// parse failures, since the ensures equal will already
-			// require equality.
-			std::string count_msg(msg);
-			count_msg += " (count)";
-			ensure_equals(count_msg, parsed_count, expected_count);
-		}
-
-		LLPointer<parser_t> mParser;
-	};
-
-
-	/**
-	 * @class TestLLSDXMLParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser>
-	{
-	public:
-		TestLLSDXMLParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup;
-	typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject;
-	TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing");
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<1>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed xml",
-			"<llsd><string>ha ha</string>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"not llsd",
-			"<html><body><p>ha ha</p></body></html>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"value without llsd",
-			"<string>ha ha</string>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"key without llsd",
-			"<key>ha ha</key>",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<2>()
-	{
-		// test handling of unrecognized or unparseable llsd values
-		LLSD v;
-		v["amy"] = 23;
-		v["bob"] = LLSD();
-		v["cam"] = 1.23;
-
-		ensureParse(
-			"unknown data type",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<key>bob</key><bigint>99999999999999999</bigint>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-	}
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<3>()
-	{
-		// test handling of nested bad data
-
-		LLSD v;
-		v["amy"] = 23;
-		v["cam"] = 1.23;
-
-		ensureParse(
-			"map with html",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<html><body>ha ha</body></html>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v["amy"] = 23;
-		v["cam"] = 1.23;
-		ensureParse(
-			"map with value for key",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<string>ha ha</string>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v["amy"] = 23;
-		v["bob"] = LLSD::emptyMap();
-		v["cam"] = 1.23;
-		ensureParse(
-			"map with map of html",
-			"<llsd><map>"
-				"<key>amy</key><integer>23</integer>"
-				"<key>bob</key>"
-				"<map>"
-					"<html><body>ha ha</body></html>"
-				"</map>"
-				"<key>cam</key><real>1.23</real>"
-			"</map></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v[0] = 23;
-		v[1] = LLSD();
-		v[2] = 1.23;
-
-		ensureParse(
-			"array value of html",
-			"<llsd><array>"
-				"<integer>23</integer>"
-				"<html><body>ha ha</body></html>"
-				"<real>1.23</real>"
-			"</array></llsd>",
-			v,
-			v.size() + 1);
-
-		v.clear();
-		v[0] = 23;
-		v[1] = LLSD::emptyMap();
-		v[2] = 1.23;
-		ensureParse(
-			"array with map of html",
-			"<llsd><array>"
-				"<integer>23</integer>"
-				"<map>"
-					"<html><body>ha ha</body></html>"
-				"</map>"
-				"<real>1.23</real>"
-			"</array></llsd>",
-			v,
-			v.size() + 1);
-	}
-
-	template<> template<> 
-	void TestLLSDXMLParsingObject::test<4>()
-	{
-		// test handling of binary object in XML
-		std::string xml;
-		LLSD expected;
-
-		// Generated by: echo -n 'hello' | openssl enc -e -base64
-		expected = string_to_vector("hello");
-		xml = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
-		ensureParse(
-			"the word 'hello' packed in binary encoded base64",
-			xml,
-			expected,
-			1);
-
-		expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		ensureParse(
-			"a common binary blob for object -> agent offline inv transfer",
-			xml,
-			expected,
-			1);
-
-		expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
-		xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBl\n";
-		xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5\n";
-		xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZm\n";
-		xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMy\n";
-		xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
-		ensureParse(
-			"a common binary blob for object -> agent offline inv transfer",
-			xml,
-			expected,
-			1);
-	}
+    /**
+     * @class TestLLSDParsing
+     * @brief Base class for of a parse tester.
+     */
+    template <class parser_t>
+    class TestLLSDParsing
+    {
+    public:
+        TestLLSDParsing()
+        {
+            mParser = new parser_t;
+        }
+
+        void ensureParse(
+            const std::string& msg,
+            const std::string& in,
+            const LLSD& expected_value,
+            S32 expected_count,
+            S32 depth_limit = -1)
+        {
+            std::stringstream input;
+            input.str(in);
+
+            LLSD parsed_result;
+            mParser->reset();   // reset() call is needed since test code re-uses mParser
+            S32 parsed_count = mParser->parse(input, parsed_result, in.size(), depth_limit);
+            ensure_equals(msg.c_str(), parsed_result, expected_value);
+
+            // This count check is really only useful for expected
+            // parse failures, since the ensures equal will already
+            // require equality.
+            std::string count_msg(msg);
+            count_msg += " (count)";
+            ensure_equals(count_msg, parsed_count, expected_count);
+        }
+
+        LLPointer<parser_t> mParser;
+    };
+
+
+    /**
+     * @class TestLLSDXMLParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser>
+    {
+    public:
+        TestLLSDXMLParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup;
+    typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject;
+    TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing");
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<1>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed xml",
+            "<llsd><string>ha ha</string>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "not llsd",
+            "<html><body><p>ha ha</p></body></html>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "value without llsd",
+            "<string>ha ha</string>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "key without llsd",
+            "<key>ha ha</key>",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<2>()
+    {
+        // test handling of unrecognized or unparseable llsd values
+        LLSD v;
+        v["amy"] = 23;
+        v["bob"] = LLSD();
+        v["cam"] = 1.23;
+
+        ensureParse(
+            "unknown data type",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<key>bob</key><bigint>99999999999999999</bigint>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+    }
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<3>()
+    {
+        // test handling of nested bad data
+
+        LLSD v;
+        v["amy"] = 23;
+        v["cam"] = 1.23;
+
+        ensureParse(
+            "map with html",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<html><body>ha ha</body></html>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v["amy"] = 23;
+        v["cam"] = 1.23;
+        ensureParse(
+            "map with value for key",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<string>ha ha</string>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v["amy"] = 23;
+        v["bob"] = LLSD::emptyMap();
+        v["cam"] = 1.23;
+        ensureParse(
+            "map with map of html",
+            "<llsd><map>"
+                "<key>amy</key><integer>23</integer>"
+                "<key>bob</key>"
+                "<map>"
+                    "<html><body>ha ha</body></html>"
+                "</map>"
+                "<key>cam</key><real>1.23</real>"
+            "</map></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v[0] = 23;
+        v[1] = LLSD();
+        v[2] = 1.23;
+
+        ensureParse(
+            "array value of html",
+            "<llsd><array>"
+                "<integer>23</integer>"
+                "<html><body>ha ha</body></html>"
+                "<real>1.23</real>"
+            "</array></llsd>",
+            v,
+            v.size() + 1);
+
+        v.clear();
+        v[0] = 23;
+        v[1] = LLSD::emptyMap();
+        v[2] = 1.23;
+        ensureParse(
+            "array with map of html",
+            "<llsd><array>"
+                "<integer>23</integer>"
+                "<map>"
+                    "<html><body>ha ha</body></html>"
+                "</map>"
+                "<real>1.23</real>"
+            "</array></llsd>",
+            v,
+            v.size() + 1);
+    }
+
+    template<> template<>
+    void TestLLSDXMLParsingObject::test<4>()
+    {
+        // test handling of binary object in XML
+        std::string xml;
+        LLSD expected;
+
+        // Generated by: echo -n 'hello' | openssl enc -e -base64
+        expected = string_to_vector("hello");
+        xml = "<llsd><binary encoding=\"base64\">aGVsbG8=</binary></llsd>\n";
+        ensureParse(
+            "the word 'hello' packed in binary encoded base64",
+            xml,
+            expected,
+            1);
+
+        expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        ensureParse(
+            "a common binary blob for object -> agent offline inv transfer",
+            xml,
+            expected,
+            1);
+
+        expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
+        xml = "<llsd><binary encoding=\"base64\">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBl\n";
+        xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5\n";
+        xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZm\n";
+        xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMy\n";
+        xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>\n";
+        ensureParse(
+            "a common binary blob for object -> agent offline inv transfer",
+            xml,
+            expected,
+            1);
+    }
 
     template<> template<>
     void TestLLSDXMLParsingObject::test<5>()
@@ -858,272 +858,272 @@ namespace tut
     }
 
 
-	/*
-	TODO:
-		test XML parsing
-			binary with unrecognized encoding
-			nested LLSD tags
-			multiple values inside an LLSD
-	*/
-
-
-	/**
-	 * @class TestLLSDNotationParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser>
-	{
-	public:
-		TestLLSDNotationParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup;
-	typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject;
-	TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup(
-		"llsd notation parsing");
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<1>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed notation map",
-			"{'ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed notation array",
-			"['ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed notation string",
-			"'ha ha",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"bad notation noise",
-			"g48ejlnfr",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<2>()
-	{
-		ensureParse("valid undef", "!", LLSD(), 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<3>()
-	{
-		LLSD val = false;
-		ensureParse("valid boolean false 0", "false", val, 1);
-		ensureParse("valid boolean false 1", "f", val, 1);
-		ensureParse("valid boolean false 2", "0", val, 1);
-		ensureParse("valid boolean false 3", "F", val, 1);
-		ensureParse("valid boolean false 4", "FALSE", val, 1);
-		val = true;
-		ensureParse("valid boolean true 0", "true", val, 1);
-		ensureParse("valid boolean true 1", "t", val, 1);
-		ensureParse("valid boolean true 2", "1", val, 1);
-		ensureParse("valid boolean true 3", "T", val, 1);
-		ensureParse("valid boolean true 4", "TRUE", val, 1);
-
-		val.clear();
-		ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE);
-		ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<4>()
-	{
-		LLSD val = 123;
-		ensureParse("valid integer", "i123", val, 1);
-		val.clear();
-		ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<5>()
-	{
-		LLSD val = 456.7;
-		ensureParse("valid real", "r456.7", val, 1);
-		val.clear();
-		ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<6>()
-	{
-		LLUUID id;
-		LLSD val = id;
-		ensureParse(
-			"unparseable uuid",
-			"u123",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		id.generate();
-		val = id;
-		std::string uuid_str("u");
-		uuid_str += id.asString();
-		ensureParse("valid uuid", uuid_str.c_str(), val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<7>()
-	{
-		LLSD val = std::string("foolish");
-		ensureParse("valid string 1", "\"foolish\"", val, 1);
-		val = std::string("g'day");
-		ensureParse("valid string 2", "\"g'day\"", val, 1);
-		val = std::string("have a \"nice\" day");
-		ensureParse("valid string 3", "'have a \"nice\" day'", val, 1);
-		val = std::string("whatever");
-		ensureParse("valid string 4", "s(8)\"whatever\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<8>()
-	{
-		ensureParse(
-			"invalid string 1",
-			"s(7)\"whatever\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"invalid string 2",
-			"s(9)\"whatever\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<9>()
-	{
-		LLSD val = LLURI("http://www.google.com");
-		ensureParse("valid uri", "l\"http://www.google.com\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<10>()
-	{
-		LLSD val = LLDate("2007-12-28T09:22:53.10Z");
-		ensureParse("valid date", "d\"2007-12-28T09:22:53.10Z\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<11>()
-	{
-		std::vector<U8> vec;
-		vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c');
-		vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1');
-		LLSD val = vec;
-		ensureParse("valid binary b64", "b64\"YWJjMzIx\"", val, 1);
-		ensureParse("valid bainry b16", "b16\"616263333231\"", val, 1);
-		ensureParse("valid bainry raw", "b(6)\"abc321\"", val, 1);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<12>()
-	{
-		ensureParse(
-			"invalid -- binary length specified too long",
-			"b(7)\"abc321\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"invalid -- binary length specified way too long",
-			"b(1000000)\"abc321\"",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<13>()
-	{
-		LLSD val;
-		val["amy"] = 23;
-		val["bob"] = LLSD();
-		val["cam"] = 1.23;
-		ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4);
-
-		val["bob"] = LLSD::emptyMap();
-		val["bob"]["vehicle"] = std::string("bicycle");
-		ensureParse(
-			"nested map",
-			"{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}",
-			val,
-			5);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<14>()
-	{
-		LLSD val;
-		val.append(23);
-		val.append(LLSD());
-		val.append(1.23);
-		ensureParse("simple array", "[i23,!,r1.23]", val, 4);
-		val[1] = LLSD::emptyArray();
-		val[1].append("bicycle");
-		ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<15>()
-	{
-		LLSD val;
-		val["amy"] = 23;
-		val["bob"]["dogs"] = LLSD::emptyArray();
-		val["bob"]["dogs"].append(LLSD::emptyMap());
-		val["bob"]["dogs"][0]["name"] = std::string("groove");
-		val["bob"]["dogs"][0]["breed"] = std::string("samoyed");
-		val["bob"]["dogs"].append(LLSD::emptyMap());
-		val["bob"]["dogs"][1]["name"] = std::string("greyley");
-		val["bob"]["dogs"][1]["breed"] = std::string("chow/husky");
-		val["cam"] = 1.23;
-		ensureParse(
-			"nested notation",
-			"{'amy':i23,"
-			" 'bob':{'dogs':["
-			         "{'name':'groove', 'breed':'samoyed'},"
-			         "{'name':'greyley', 'breed':'chow/husky'}]},"
-			" 'cam':r1.23}",
-			val,
-			11);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<16>()
-	{
-		// text to make sure that incorrect sizes bail because 
-		std::string bad_str("s(5)\"hi\"");
-		ensureParse(
-			"size longer than bytes left",
-			bad_str,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDNotationParsingObject::test<17>()
-	{
-		// text to make sure that incorrect sizes bail because 
-		std::string bad_bin("b(5)\"hi\"");
-		ensureParse(
-			"size longer than bytes left",
-			bad_bin,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
+    /*
+    TODO:
+        test XML parsing
+            binary with unrecognized encoding
+            nested LLSD tags
+            multiple values inside an LLSD
+    */
+
+
+    /**
+     * @class TestLLSDNotationParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser>
+    {
+    public:
+        TestLLSDNotationParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup;
+    typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject;
+    TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup(
+        "llsd notation parsing");
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<1>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed notation map",
+            "{'ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed notation array",
+            "['ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed notation string",
+            "'ha ha",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "bad notation noise",
+            "g48ejlnfr",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<2>()
+    {
+        ensureParse("valid undef", "!", LLSD(), 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<3>()
+    {
+        LLSD val = false;
+        ensureParse("valid boolean false 0", "false", val, 1);
+        ensureParse("valid boolean false 1", "f", val, 1);
+        ensureParse("valid boolean false 2", "0", val, 1);
+        ensureParse("valid boolean false 3", "F", val, 1);
+        ensureParse("valid boolean false 4", "FALSE", val, 1);
+        val = true;
+        ensureParse("valid boolean true 0", "true", val, 1);
+        ensureParse("valid boolean true 1", "t", val, 1);
+        ensureParse("valid boolean true 2", "1", val, 1);
+        ensureParse("valid boolean true 3", "T", val, 1);
+        ensureParse("valid boolean true 4", "TRUE", val, 1);
+
+        val.clear();
+        ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE);
+        ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<4>()
+    {
+        LLSD val = 123;
+        ensureParse("valid integer", "i123", val, 1);
+        val.clear();
+        ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<5>()
+    {
+        LLSD val = 456.7;
+        ensureParse("valid real", "r456.7", val, 1);
+        val.clear();
+        ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<6>()
+    {
+        LLUUID id;
+        LLSD val = id;
+        ensureParse(
+            "unparseable uuid",
+            "u123",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        id.generate();
+        val = id;
+        std::string uuid_str("u");
+        uuid_str += id.asString();
+        ensureParse("valid uuid", uuid_str.c_str(), val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<7>()
+    {
+        LLSD val = std::string("foolish");
+        ensureParse("valid string 1", "\"foolish\"", val, 1);
+        val = std::string("g'day");
+        ensureParse("valid string 2", "\"g'day\"", val, 1);
+        val = std::string("have a \"nice\" day");
+        ensureParse("valid string 3", "'have a \"nice\" day'", val, 1);
+        val = std::string("whatever");
+        ensureParse("valid string 4", "s(8)\"whatever\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<8>()
+    {
+        ensureParse(
+            "invalid string 1",
+            "s(7)\"whatever\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "invalid string 2",
+            "s(9)\"whatever\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<9>()
+    {
+        LLSD val = LLURI("http://www.google.com");
+        ensureParse("valid uri", "l\"http://www.google.com\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<10>()
+    {
+        LLSD val = LLDate("2007-12-28T09:22:53.10Z");
+        ensureParse("valid date", "d\"2007-12-28T09:22:53.10Z\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<11>()
+    {
+        std::vector<U8> vec;
+        vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c');
+        vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1');
+        LLSD val = vec;
+        ensureParse("valid binary b64", "b64\"YWJjMzIx\"", val, 1);
+        ensureParse("valid bainry b16", "b16\"616263333231\"", val, 1);
+        ensureParse("valid bainry raw", "b(6)\"abc321\"", val, 1);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<12>()
+    {
+        ensureParse(
+            "invalid -- binary length specified too long",
+            "b(7)\"abc321\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "invalid -- binary length specified way too long",
+            "b(1000000)\"abc321\"",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<13>()
+    {
+        LLSD val;
+        val["amy"] = 23;
+        val["bob"] = LLSD();
+        val["cam"] = 1.23;
+        ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4);
+
+        val["bob"] = LLSD::emptyMap();
+        val["bob"]["vehicle"] = std::string("bicycle");
+        ensureParse(
+            "nested map",
+            "{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}",
+            val,
+            5);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<14>()
+    {
+        LLSD val;
+        val.append(23);
+        val.append(LLSD());
+        val.append(1.23);
+        ensureParse("simple array", "[i23,!,r1.23]", val, 4);
+        val[1] = LLSD::emptyArray();
+        val[1].append("bicycle");
+        ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<15>()
+    {
+        LLSD val;
+        val["amy"] = 23;
+        val["bob"]["dogs"] = LLSD::emptyArray();
+        val["bob"]["dogs"].append(LLSD::emptyMap());
+        val["bob"]["dogs"][0]["name"] = std::string("groove");
+        val["bob"]["dogs"][0]["breed"] = std::string("samoyed");
+        val["bob"]["dogs"].append(LLSD::emptyMap());
+        val["bob"]["dogs"][1]["name"] = std::string("greyley");
+        val["bob"]["dogs"][1]["breed"] = std::string("chow/husky");
+        val["cam"] = 1.23;
+        ensureParse(
+            "nested notation",
+            "{'amy':i23,"
+            " 'bob':{'dogs':["
+                     "{'name':'groove', 'breed':'samoyed'},"
+                     "{'name':'greyley', 'breed':'chow/husky'}]},"
+            " 'cam':r1.23}",
+            val,
+            11);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<16>()
+    {
+        // text to make sure that incorrect sizes bail because
+        std::string bad_str("s(5)\"hi\"");
+        ensureParse(
+            "size longer than bytes left",
+            bad_str,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDNotationParsingObject::test<17>()
+    {
+        // text to make sure that incorrect sizes bail because
+        std::string bad_bin("b(5)\"hi\"");
+        ensureParse(
+            "size longer than bytes left",
+            bad_bin,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
 
     template<> template<>
     void TestLLSDNotationParsingObject::test<18>()
     {
-        LLSD level_1 = LLSD::emptyMap();		level_1["level_2"] = 99;
-        LLSD level_0 = LLSD::emptyMap();		level_0["level_1"] = level_1;
+        LLSD level_1 = LLSD::emptyMap();        level_1["level_2"] = 99;
+        LLSD level_0 = LLSD::emptyMap();        level_0["level_1"] = level_1;
 
         LLSD deep = LLSD::emptyMap();
         deep["level_0"] = level_0;
@@ -1168,7 +1168,7 @@ namespace tut
     template<> template<>
     void TestLLSDNotationParsingObject::test<20>()
     {
-        LLSD end = LLSD::emptyMap();		  end["end"] = (S32)99;
+        LLSD end = LLSD::emptyMap();          end["end"] = (S32)99;
 
         LLSD level_49 = LLSD::emptyMap();     level_49["level_49"] = end;
         LLSD level_48 = LLSD::emptyMap();     level_48["level_48"] = level_49;
@@ -1259,536 +1259,536 @@ namespace tut
             9);
     }
 
-	/**
-	 * @class TestLLSDBinaryParsing
-	 * @brief Concrete instance of a parse tester.
-	 */
-	class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser>
-	{
-	public:
-		TestLLSDBinaryParsing() {}
-	};
-
-	typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup;
-	typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject;
-	TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup(
-		"llsd binary parsing");
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<1>()
-	{
-		std::vector<U8> vec;
-		vec.resize(6);
-		vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
-		vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
-		std::string string_expected((char*)&vec[0], vec.size());
-		LLSD value = string_expected;
-
-		vec.resize(11);
-		vec[0] = 's'; // for string
-		vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
-		vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
-
-		uint32_t size = htonl(6);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse("correct string parse", str_good, value, 1);
-
-		size = htonl(7);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size string parse",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(100000);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size string parse",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<2>()
-	{
-		std::vector<U8> vec;
-		vec.resize(6);
-		vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
-		vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
-		LLSD value = vec;
-
-		vec.resize(11);
-		vec[0] = 'b';  // for binary
-		vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
-		vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
-
-		uint32_t size = htonl(6);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse("correct binary parse", str_good, value, 1);
-
-		size = htonl(7);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size binary parse 1",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(100000);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"incorrect size binary parse 2",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<3>()
-	{
-		// test handling of xml not recognized as llsd results in an
-		// LLSD Undefined
-		ensureParse(
-			"malformed binary map",
-			"{'ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed binary array",
-			"['ha ha'",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"malformed binary string",
-			"'ha ha",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-		ensureParse(
-			"bad noise",
-			"g48ejlnfr",
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<4>()
-	{
-		ensureParse("valid undef", "!", LLSD(), 1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<5>()
-	{
-		LLSD val = false;
-		ensureParse("valid boolean false 2", "0", val, 1);
-		val = true;
-		ensureParse("valid boolean true 2", "1", val, 1);
-
-		val.clear();
-		ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE);
-		ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<6>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('{');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(1);
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('k');
-		int key_size_loc = vec.size();
-		size = htonl(1); // 1 too short
-		vec.resize(vec.size() + 4);
-		memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
-		vec.push_back('a'); vec.push_back('m'); vec.push_back('y');
-		vec.push_back('i');
-		int integer_loc = vec.size();
-		vec.resize(vec.size() + 4);
-		uint32_t val_int = htonl(23);
-		memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid key size",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check with correct size, but unterminated map (missing '}')
-		size = htonl(3); // correct size
-		memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid key size, unterminated map",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check w/ correct size and correct map termination
-		LLSD val;
-		val["amy"] = 23;
-		vec.push_back('}');
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid map",
-			str_good,
-			val,
-			2);
-
-		// check w/ incorrect sizes and correct map termination
-		size = htonl(0); // 1 too few (for the map entry)
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_3((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid map too long",
-			str_bad_3,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		size = htonl(2); // 1 too many
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_4((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid map too short",
-			str_bad_4,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<7>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('[');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(1); // 1 too short
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('"'); vec.push_back('a'); vec.push_back('m');
-		vec.push_back('y'); vec.push_back('"'); vec.push_back('i');
-		int integer_loc = vec.size();
-		vec.resize(vec.size() + 4);
-		uint32_t val_int = htonl(23);
-		memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
-
-		std::string str_bad_1((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid array size",
-			str_bad_1,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check with correct size, but unterminated map (missing ']')
-		size = htonl(2); // correct size
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_2((char*)&vec[0], vec.size());
-		ensureParse(
-			"unterminated array",
-			str_bad_2,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		// check w/ correct size and correct map termination
-		LLSD val;
-		val.append("amy");
-		val.append(23);
-		vec.push_back(']');
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid array",
-			str_good,
-			val,
-			3);
-
-		// check with too many elements
-		size = htonl(3); // 1 too long
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_bad_3((char*)&vec[0], vec.size());
-		ensureParse(
-			"array too short",
-			str_bad_3,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<8>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('{');
-		vec.resize(vec.size() + 4);
-		memset(&vec[1], 0, 4);
-		vec.push_back('}');
-		std::string str_good((char*)&vec[0], vec.size());
-		LLSD val = LLSD::emptyMap();
-		ensureParse(
-			"empty map",
-			str_good,
-			val,
-			1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<9>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('[');
-		vec.resize(vec.size() + 4);
-		memset(&vec[1], 0, 4);
-		vec.push_back(']');
-		std::string str_good((char*)&vec[0], vec.size());
-		LLSD val = LLSD::emptyArray();
-		ensureParse(
-			"empty array",
-			str_good,
-			val,
-			1);
-	}
-
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<10>()
-	{
-		std::vector<U8> vec;
-		vec.push_back('l');
-		vec.resize(vec.size() + 4);
-		uint32_t size = htonl(14); // 1 too long
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		vec.push_back('h'); vec.push_back('t'); vec.push_back('t');
-		vec.push_back('p'); vec.push_back(':'); vec.push_back('/');
-		vec.push_back('/'); vec.push_back('s'); vec.push_back('l');
-		vec.push_back('.'); vec.push_back('c'); vec.push_back('o');
-		vec.push_back('m');
-		std::string str_bad((char*)&vec[0], vec.size());
-		ensureParse(
-			"invalid uri length size",
-			str_bad,
-			LLSD(),
-			LLSDParser::PARSE_FAILURE);
-
-		LLSD val;
-		val = LLURI("http://sl.com");
-		size = htonl(13); // correct length
-		memcpy(&vec[1], &size, sizeof(uint32_t));
-		std::string str_good((char*)&vec[0], vec.size());
-		ensureParse(
-			"valid key size",
-			str_good,
-			val,
-			1);
-	}
+    /**
+     * @class TestLLSDBinaryParsing
+     * @brief Concrete instance of a parse tester.
+     */
+    class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser>
+    {
+    public:
+        TestLLSDBinaryParsing() {}
+    };
+
+    typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup;
+    typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject;
+    TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup(
+        "llsd binary parsing");
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<1>()
+    {
+        std::vector<U8> vec;
+        vec.resize(6);
+        vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
+        vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
+        std::string string_expected((char*)&vec[0], vec.size());
+        LLSD value = string_expected;
+
+        vec.resize(11);
+        vec[0] = 's'; // for string
+        vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
+        vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
+
+        uint32_t size = htonl(6);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse("correct string parse", str_good, value, 1);
+
+        size = htonl(7);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size string parse",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(100000);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size string parse",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<2>()
+    {
+        std::vector<U8> vec;
+        vec.resize(6);
+        vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
+        vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
+        LLSD value = vec;
+
+        vec.resize(11);
+        vec[0] = 'b';  // for binary
+        vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
+        vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
+
+        uint32_t size = htonl(6);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse("correct binary parse", str_good, value, 1);
+
+        size = htonl(7);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size binary parse 1",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(100000);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "incorrect size binary parse 2",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<3>()
+    {
+        // test handling of xml not recognized as llsd results in an
+        // LLSD Undefined
+        ensureParse(
+            "malformed binary map",
+            "{'ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed binary array",
+            "['ha ha'",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "malformed binary string",
+            "'ha ha",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+        ensureParse(
+            "bad noise",
+            "g48ejlnfr",
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<4>()
+    {
+        ensureParse("valid undef", "!", LLSD(), 1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<5>()
+    {
+        LLSD val = false;
+        ensureParse("valid boolean false 2", "0", val, 1);
+        val = true;
+        ensureParse("valid boolean true 2", "1", val, 1);
+
+        val.clear();
+        ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE);
+        ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<6>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('{');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(1);
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('k');
+        int key_size_loc = vec.size();
+        size = htonl(1); // 1 too short
+        vec.resize(vec.size() + 4);
+        memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
+        vec.push_back('a'); vec.push_back('m'); vec.push_back('y');
+        vec.push_back('i');
+        int integer_loc = vec.size();
+        vec.resize(vec.size() + 4);
+        uint32_t val_int = htonl(23);
+        memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid key size",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check with correct size, but unterminated map (missing '}')
+        size = htonl(3); // correct size
+        memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid key size, unterminated map",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check w/ correct size and correct map termination
+        LLSD val;
+        val["amy"] = 23;
+        vec.push_back('}');
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid map",
+            str_good,
+            val,
+            2);
+
+        // check w/ incorrect sizes and correct map termination
+        size = htonl(0); // 1 too few (for the map entry)
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_3((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid map too long",
+            str_bad_3,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        size = htonl(2); // 1 too many
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_4((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid map too short",
+            str_bad_4,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<7>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('[');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(1); // 1 too short
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('"'); vec.push_back('a'); vec.push_back('m');
+        vec.push_back('y'); vec.push_back('"'); vec.push_back('i');
+        int integer_loc = vec.size();
+        vec.resize(vec.size() + 4);
+        uint32_t val_int = htonl(23);
+        memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
+
+        std::string str_bad_1((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid array size",
+            str_bad_1,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check with correct size, but unterminated map (missing ']')
+        size = htonl(2); // correct size
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_2((char*)&vec[0], vec.size());
+        ensureParse(
+            "unterminated array",
+            str_bad_2,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        // check w/ correct size and correct map termination
+        LLSD val;
+        val.append("amy");
+        val.append(23);
+        vec.push_back(']');
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid array",
+            str_good,
+            val,
+            3);
+
+        // check with too many elements
+        size = htonl(3); // 1 too long
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_bad_3((char*)&vec[0], vec.size());
+        ensureParse(
+            "array too short",
+            str_bad_3,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<8>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('{');
+        vec.resize(vec.size() + 4);
+        memset(&vec[1], 0, 4);
+        vec.push_back('}');
+        std::string str_good((char*)&vec[0], vec.size());
+        LLSD val = LLSD::emptyMap();
+        ensureParse(
+            "empty map",
+            str_good,
+            val,
+            1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<9>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('[');
+        vec.resize(vec.size() + 4);
+        memset(&vec[1], 0, 4);
+        vec.push_back(']');
+        std::string str_good((char*)&vec[0], vec.size());
+        LLSD val = LLSD::emptyArray();
+        ensureParse(
+            "empty array",
+            str_good,
+            val,
+            1);
+    }
+
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<10>()
+    {
+        std::vector<U8> vec;
+        vec.push_back('l');
+        vec.resize(vec.size() + 4);
+        uint32_t size = htonl(14); // 1 too long
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        vec.push_back('h'); vec.push_back('t'); vec.push_back('t');
+        vec.push_back('p'); vec.push_back(':'); vec.push_back('/');
+        vec.push_back('/'); vec.push_back('s'); vec.push_back('l');
+        vec.push_back('.'); vec.push_back('c'); vec.push_back('o');
+        vec.push_back('m');
+        std::string str_bad((char*)&vec[0], vec.size());
+        ensureParse(
+            "invalid uri length size",
+            str_bad,
+            LLSD(),
+            LLSDParser::PARSE_FAILURE);
+
+        LLSD val;
+        val = LLURI("http://sl.com");
+        size = htonl(13); // correct length
+        memcpy(&vec[1], &size, sizeof(uint32_t));
+        std::string str_good((char*)&vec[0], vec.size());
+        ensureParse(
+            "valid key size",
+            str_good,
+            val,
+            1);
+    }
 
 /*
-	template<> template<> 
-	void TestLLSDBinaryParsingObject::test<11>()
-	{
-	}
+    template<> template<>
+    void TestLLSDBinaryParsingObject::test<11>()
+    {
+    }
 */
 
    /**
-	 * @class TestLLSDCrossCompatible
-	 * @brief Miscellaneous serialization and parsing tests
-	 */
-	class TestLLSDCrossCompatible
-	{
-	public:
-		TestLLSDCrossCompatible() {}
-
-		void ensureBinaryAndNotation(
-			const std::string& msg,
-			const LLSD& input)
-		{
-			// to binary, and back again
-			std::stringstream str1;
-			S32 count1 = LLSDSerialize::toBinary(input, str1);
-			LLSD actual_value_bin;
-			S32 count2 = LLSDSerialize::fromBinary(
-				actual_value_bin,
-				str1,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndNotation binary count",
-				count2,
-				count1);
-
-			// to notation and back again
-			std::stringstream str2;
-			S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2);
-			ensure_equals(
-				"ensureBinaryAndNotation notation count1",
-				count3,
-				count2);
-			LLSD actual_value_notation;
-			S32 count4 = LLSDSerialize::fromNotation(
-				actual_value_notation,
-				str2,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndNotation notation count2",
-				count4,
-				count3);
-			ensure_equals(
-				(msg + " (binaryandnotation)").c_str(),
-				actual_value_notation,
-				input);
-		}
-
-		void ensureBinaryAndXML(
-			const std::string& msg,
-			const LLSD& input)
-		{
-			// to binary, and back again
-			std::stringstream str1;
-			S32 count1 = LLSDSerialize::toBinary(input, str1);
-			LLSD actual_value_bin;
-			S32 count2 = LLSDSerialize::fromBinary(
-				actual_value_bin,
-				str1,
-				LLSDSerialize::SIZE_UNLIMITED);
-			ensure_equals(
-				"ensureBinaryAndXML binary count",
-				count2,
-				count1);
-
-			// to xml and back again
-			std::stringstream str2;
-			S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2);
-			ensure_equals(
-				"ensureBinaryAndXML xml count1",
-				count3,
-				count2);
-			LLSD actual_value_xml;
-			S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2);
-			ensure_equals(
-				"ensureBinaryAndXML xml count2",
-				count4,
-				count3);
-			ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input);
-		}
-	};
-
-	typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup;
-	typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject;
-	TestLLSDCompatibleGroup gTestLLSDCompatibleGroup(
-		"llsd serialize compatible");
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<1>()
-	{
-		LLSD test;
-		ensureBinaryAndNotation("undef", test);
-		ensureBinaryAndXML("undef", test);
-		test = true;
-		ensureBinaryAndNotation("boolean true", test);
-		ensureBinaryAndXML("boolean true", test);
-		test = false;
-		ensureBinaryAndNotation("boolean false", test);
-		ensureBinaryAndXML("boolean false", test);
-		test = 0;
-		ensureBinaryAndNotation("integer zero", test);
-		ensureBinaryAndXML("integer zero", test);
-		test = 1;
-		ensureBinaryAndNotation("integer positive", test);
-		ensureBinaryAndXML("integer positive", test);
-		test = -234567;
-		ensureBinaryAndNotation("integer negative", test);
-		ensureBinaryAndXML("integer negative", test);
-		test = 0.0;
-		ensureBinaryAndNotation("real zero", test);
-		ensureBinaryAndXML("real zero", test);
-		test = 1.0;
-		ensureBinaryAndNotation("real positive", test);
-		ensureBinaryAndXML("real positive", test);
-		test = -1.0;
-		ensureBinaryAndNotation("real negative", test);
-		ensureBinaryAndXML("real negative", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<2>()
-	{
-		LLSD test;
-		test = "foobar";
-		ensureBinaryAndNotation("string", test);
-		ensureBinaryAndXML("string", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<3>()
-	{
-		LLSD test;
-		LLUUID id;
-		id.generate();
-		test = id;
-		ensureBinaryAndNotation("uuid", test);
-		ensureBinaryAndXML("uuid", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<4>()
-	{
-		LLSD test;
-		test = LLDate(12345.0);
-		ensureBinaryAndNotation("date", test);
-		ensureBinaryAndXML("date", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<5>()
-	{
-		LLSD test;
-		test = LLURI("http://www.secondlife.com/");
-		ensureBinaryAndNotation("uri", test);
-		ensureBinaryAndXML("uri", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<6>()
-	{
-		LLSD test;
-		typedef std::vector<U8> buf_t;
-		buf_t val;
-		for(int ii = 0; ii < 100; ++ii)
-		{
-			srand(ii);		/* Flawfinder: ignore */
-			S32 size = rand() % 100 + 10;
-			std::generate_n(
-				std::back_insert_iterator<buf_t>(val),
-				size,
-				rand);
-		}
-		test = val;
-		ensureBinaryAndNotation("binary", test);
-		ensureBinaryAndXML("binary", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<7>()
-	{
-		LLSD test;
-		test = LLSD::emptyArray();
-		test.append(1);
-		test.append("hello");
-		ensureBinaryAndNotation("array", test);
-		ensureBinaryAndXML("array", test);
-	}
-
-	template<> template<> 
-	void TestLLSDCompatibleObject::test<8>()
-	{
-		LLSD test;
-		test = LLSD::emptyArray();
-		test["foo"] = "bar";
-		test["baz"] = 100;
-		ensureBinaryAndNotation("map", test);
-		ensureBinaryAndXML("map", test);
-	}
+     * @class TestLLSDCrossCompatible
+     * @brief Miscellaneous serialization and parsing tests
+     */
+    class TestLLSDCrossCompatible
+    {
+    public:
+        TestLLSDCrossCompatible() {}
+
+        void ensureBinaryAndNotation(
+            const std::string& msg,
+            const LLSD& input)
+        {
+            // to binary, and back again
+            std::stringstream str1;
+            S32 count1 = LLSDSerialize::toBinary(input, str1);
+            LLSD actual_value_bin;
+            S32 count2 = LLSDSerialize::fromBinary(
+                actual_value_bin,
+                str1,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndNotation binary count",
+                count2,
+                count1);
+
+            // to notation and back again
+            std::stringstream str2;
+            S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2);
+            ensure_equals(
+                "ensureBinaryAndNotation notation count1",
+                count3,
+                count2);
+            LLSD actual_value_notation;
+            S32 count4 = LLSDSerialize::fromNotation(
+                actual_value_notation,
+                str2,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndNotation notation count2",
+                count4,
+                count3);
+            ensure_equals(
+                (msg + " (binaryandnotation)").c_str(),
+                actual_value_notation,
+                input);
+        }
+
+        void ensureBinaryAndXML(
+            const std::string& msg,
+            const LLSD& input)
+        {
+            // to binary, and back again
+            std::stringstream str1;
+            S32 count1 = LLSDSerialize::toBinary(input, str1);
+            LLSD actual_value_bin;
+            S32 count2 = LLSDSerialize::fromBinary(
+                actual_value_bin,
+                str1,
+                LLSDSerialize::SIZE_UNLIMITED);
+            ensure_equals(
+                "ensureBinaryAndXML binary count",
+                count2,
+                count1);
+
+            // to xml and back again
+            std::stringstream str2;
+            S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2);
+            ensure_equals(
+                "ensureBinaryAndXML xml count1",
+                count3,
+                count2);
+            LLSD actual_value_xml;
+            S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2);
+            ensure_equals(
+                "ensureBinaryAndXML xml count2",
+                count4,
+                count3);
+            ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input);
+        }
+    };
+
+    typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup;
+    typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject;
+    TestLLSDCompatibleGroup gTestLLSDCompatibleGroup(
+        "llsd serialize compatible");
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<1>()
+    {
+        LLSD test;
+        ensureBinaryAndNotation("undef", test);
+        ensureBinaryAndXML("undef", test);
+        test = true;
+        ensureBinaryAndNotation("boolean true", test);
+        ensureBinaryAndXML("boolean true", test);
+        test = false;
+        ensureBinaryAndNotation("boolean false", test);
+        ensureBinaryAndXML("boolean false", test);
+        test = 0;
+        ensureBinaryAndNotation("integer zero", test);
+        ensureBinaryAndXML("integer zero", test);
+        test = 1;
+        ensureBinaryAndNotation("integer positive", test);
+        ensureBinaryAndXML("integer positive", test);
+        test = -234567;
+        ensureBinaryAndNotation("integer negative", test);
+        ensureBinaryAndXML("integer negative", test);
+        test = 0.0;
+        ensureBinaryAndNotation("real zero", test);
+        ensureBinaryAndXML("real zero", test);
+        test = 1.0;
+        ensureBinaryAndNotation("real positive", test);
+        ensureBinaryAndXML("real positive", test);
+        test = -1.0;
+        ensureBinaryAndNotation("real negative", test);
+        ensureBinaryAndXML("real negative", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<2>()
+    {
+        LLSD test;
+        test = "foobar";
+        ensureBinaryAndNotation("string", test);
+        ensureBinaryAndXML("string", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<3>()
+    {
+        LLSD test;
+        LLUUID id;
+        id.generate();
+        test = id;
+        ensureBinaryAndNotation("uuid", test);
+        ensureBinaryAndXML("uuid", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<4>()
+    {
+        LLSD test;
+        test = LLDate(12345.0);
+        ensureBinaryAndNotation("date", test);
+        ensureBinaryAndXML("date", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<5>()
+    {
+        LLSD test;
+        test = LLURI("http://www.secondlife.com/");
+        ensureBinaryAndNotation("uri", test);
+        ensureBinaryAndXML("uri", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<6>()
+    {
+        LLSD test;
+        typedef std::vector<U8> buf_t;
+        buf_t val;
+        for(int ii = 0; ii < 100; ++ii)
+        {
+            srand(ii);      /* Flawfinder: ignore */
+            S32 size = rand() % 100 + 10;
+            std::generate_n(
+                std::back_insert_iterator<buf_t>(val),
+                size,
+                rand);
+        }
+        test = val;
+        ensureBinaryAndNotation("binary", test);
+        ensureBinaryAndXML("binary", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<7>()
+    {
+        LLSD test;
+        test = LLSD::emptyArray();
+        test.append(1);
+        test.append("hello");
+        ensureBinaryAndNotation("array", test);
+        ensureBinaryAndXML("array", test);
+    }
+
+    template<> template<>
+    void TestLLSDCompatibleObject::test<8>()
+    {
+        LLSD test;
+        test = LLSD::emptyArray();
+        test["foo"] = "bar";
+        test["baz"] = 100;
+        ensureBinaryAndNotation("map", test);
+        ensureBinaryAndXML("map", test);
+    }
 
     // helper for TestPythonCompatible
     static std::string import_llsd("import os.path\n"
@@ -2130,7 +2130,7 @@ namespace tut
                                         item.asReal(), 3.14, 7); // 7 bits ~= 0.01
             ensure("Failed to read LLSD::String from Python",
                    itemFromStream(inf, item, parse));
-            ensure_equals(item.asString(), 
+            ensure_equals(item.asString(),
                           "This string\n"
                           "has several\n"
                           "lines.");