Merge in viewer-development

16 files changed, 374 insertions, 234 deletions

diff --git a/indra/llcommon/llallocator.cpp b/indra/llcommon/llallocator.cpp
index 6f6abefc67..87654b5b97 100644
--- a/indra/llcommon/llallocator.cpp
+++ b/indra/llcommon/llallocator.cpp
@@ -27,7 +27,7 @@
 #include "linden_common.h"
 #include "llallocator.h"
 
-#if LL_USE_TCMALLOC
+#if (LL_USE_TCMALLOC && LL_USE_HEAP_PROFILER)
 
 #include "google/heap-profiler.h"
 #include "google/commandlineflags_public.h"
diff --git a/indra/llcommon/llcursortypes.cpp b/indra/llcommon/llcursortypes.cpp
index e987c397bd..ec60097195 100644
--- a/indra/llcommon/llcursortypes.cpp
+++ b/indra/llcommon/llcursortypes.cpp
@@ -69,6 +69,12 @@ ECursorType getCursorFromString(const std::string& cursor_string)
 		cursor_string_table["UI_CURSOR_TOOLSIT"] = UI_CURSOR_TOOLSIT;
 		cursor_string_table["UI_CURSOR_TOOLBUY"] = UI_CURSOR_TOOLBUY;
 		cursor_string_table["UI_CURSOR_TOOLOPEN"] = UI_CURSOR_TOOLOPEN;
+		cursor_string_table["UI_CURSOR_TOOLPATHFINDING"] = UI_CURSOR_TOOLPATHFINDING;
+		cursor_string_table["UI_CURSOR_TOOLPATHFINDINGPATHSTART"] = UI_CURSOR_TOOLPATHFINDING_PATH_START;
+		cursor_string_table["UI_CURSOR_TOOLPATHFINDINGPATHSTARTADD"] = UI_CURSOR_TOOLPATHFINDING_PATH_START_ADD;
+		cursor_string_table["UI_CURSOR_TOOLPATHFINDINGPATHEND"] = UI_CURSOR_TOOLPATHFINDING_PATH_END;
+		cursor_string_table["UI_CURSOR_TOOLPATHFINDINGPATHENDADD"] = UI_CURSOR_TOOLPATHFINDING_PATH_END_ADD;
+		cursor_string_table["UI_CURSOR_TOOLNO"] = UI_CURSOR_TOOLNO;
 	}
 
 	std::map<std::string,U32>::const_iterator iter = cursor_string_table.find(cursor_string);
diff --git a/indra/llcommon/llcursortypes.h b/indra/llcommon/llcursortypes.h
index bacb0a80ba..cb6d6636a0 100644
--- a/indra/llcommon/llcursortypes.h
+++ b/indra/llcommon/llcursortypes.h
@@ -65,6 +65,12 @@ enum ECursorType {
 	UI_CURSOR_TOOLSIT,
 	UI_CURSOR_TOOLBUY,
 	UI_CURSOR_TOOLOPEN,
+	UI_CURSOR_TOOLPATHFINDING,
+	UI_CURSOR_TOOLPATHFINDING_PATH_START,
+	UI_CURSOR_TOOLPATHFINDING_PATH_START_ADD,
+	UI_CURSOR_TOOLPATHFINDING_PATH_END,
+	UI_CURSOR_TOOLPATHFINDING_PATH_END_ADD,
+	UI_CURSOR_TOOLNO,
 	UI_CURSOR_COUNT			// Number of elements in this enum (NOT a cursor)
 };
 
diff --git a/indra/llcommon/llerror.cpp b/indra/llcommon/llerror.cpp
index 7e6eee0f3c..9b0141eb76 100644
--- a/indra/llcommon/llerror.cpp
+++ b/indra/llcommon/llerror.cpp
@@ -534,7 +534,7 @@ namespace
 	}
 	
 	
-	void commonInit(const std::string& dir)
+	void commonInit(const std::string& dir, bool log_to_stderr = true)
 	{
 		LLError::Settings::reset();
 		
@@ -542,7 +542,8 @@ namespace
 		LLError::setFatalFunction(LLError::crashAndLoop);
 		LLError::setTimeFunction(LLError::utcTime);
 
-		if (shouldLogToStderr())
+		// log_to_stderr is only false in the unit and integration tests to keep builds quieter
+		if (log_to_stderr && shouldLogToStderr())
 		{
 			LLError::addRecorder(new RecordToStderr(stderrLogWantsTime()));
 		}
@@ -580,9 +581,9 @@ namespace LLError
 #endif
 	}
 
-	void initForApplication(const std::string& dir)
+	void initForApplication(const std::string& dir, bool log_to_stderr)
 	{
-		commonInit(dir);
+		commonInit(dir, log_to_stderr);
 	}
 
 	void setPrintLocation(bool print)
diff --git a/indra/llcommon/llerror.h b/indra/llcommon/llerror.h
index b3e604f8e8..b65b410153 100644
--- a/indra/llcommon/llerror.h
+++ b/indra/llcommon/llerror.h
@@ -35,7 +35,7 @@
 #include "stdtypes.h"
 
 
-/* Error Logging Facility
+/** Error Logging Facility
 
 	Information for most users:
 	
@@ -100,7 +100,6 @@
 	even release.  Which means you can use them to help debug even when deployed
 	to a real grid.
 */
-
 namespace LLError
 {
 	enum ELevel
@@ -143,9 +142,13 @@ namespace LLError
 		CallSite(ELevel, const char* file, int line,
 				const std::type_info& class_info, const char* function, const char* broadTag, const char* narrowTag, bool printOnce);
 						
+#ifdef LL_LIBRARY_INCLUDE
+		bool shouldLog();
+#else // LL_LIBRARY_INCLUDE
 		bool shouldLog()
 			{ return mCached ? mShouldLog : Log::shouldLog(*this); }
 			// this member function needs to be in-line for efficiency
+#endif // LL_LIBRARY_INCLUDE
 		
 		void invalidate();
 		
diff --git a/indra/llcommon/llerrorcontrol.h b/indra/llcommon/llerrorcontrol.h
index d53a819d88..480654b1a2 100644
--- a/indra/llcommon/llerrorcontrol.h
+++ b/indra/llcommon/llerrorcontrol.h
@@ -62,7 +62,7 @@ namespace LLError
 		// logs to stderr, syslog, and windows debug log
 		// the identity string is used for in the syslog
 
-	LL_COMMON_API void initForApplication(const std::string& dir);
+	LL_COMMON_API void initForApplication(const std::string& dir, bool log_to_stderr = true);
 		// resets all logging settings to defaults needed by applicaitons
 		// logs to stderr and windows debug log
 		// sets up log configuration from the file logcontrol.xml in dir
diff --git a/indra/llcommon/llmemory.cpp b/indra/llcommon/llmemory.cpp
index 3b9758f996..afaf366668 100644
--- a/indra/llcommon/llmemory.cpp
+++ b/indra/llcommon/llmemory.cpp
@@ -61,6 +61,18 @@ BOOL LLMemory::sEnableMemoryFailurePrevention = FALSE;
 LLPrivateMemoryPoolManager::mem_allocation_info_t LLPrivateMemoryPoolManager::sMemAllocationTracker;
 #endif
 
+void ll_assert_aligned_func(uintptr_t ptr,U32 alignment)
+{
+#ifdef SHOW_ASSERT
+	// Redundant, place to set breakpoints.
+	if (ptr%alignment!=0)
+	{
+		llwarns << "alignment check failed" << llendl;
+	}
+	llassert(ptr%alignment==0);
+#endif
+}
+
 //static
 void LLMemory::initClass()
 {
diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index bbbdaa6497..9dd776ff57 100644
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -27,7 +27,6 @@
 #define LLMEMORY_H
 
 #include "llmemtype.h"
-#if LL_DEBUG
 inline void* ll_aligned_malloc( size_t size, int align )
 {
 	void* mem = malloc( size + (align - 1) + sizeof(void*) );
@@ -43,10 +42,11 @@ inline void ll_aligned_free( void* ptr )
 	free( ((void**)ptr)[-1] );
 }
 
+#if !LL_USE_TCMALLOC
 inline void* ll_aligned_malloc_16(size_t size) // returned hunk MUST be freed with ll_aligned_free_16().
 {
 #if defined(LL_WINDOWS)
-	return _mm_malloc(size, 16);
+	return _aligned_malloc(size, 16);
 #elif defined(LL_DARWIN)
 	return malloc(size); // default osx malloc is 16 byte aligned.
 #else
@@ -58,21 +58,38 @@ inline void* ll_aligned_malloc_16(size_t size) // returned hunk MUST be freed wi
 #endif
 }
 
+inline void* ll_aligned_realloc_16(void* ptr, size_t size) // returned hunk MUST be freed with ll_aligned_free_16().
+{
+#if defined(LL_WINDOWS)
+	return _aligned_realloc(ptr, size, 16);
+#elif defined(LL_DARWIN)
+	return realloc(ptr,size); // default osx malloc is 16 byte aligned.
+#else
+	return realloc(ptr,size); // FIXME not guaranteed to be aligned.
+#endif
+}
+
 inline void ll_aligned_free_16(void *p)
 {
 #if defined(LL_WINDOWS)
-	_mm_free(p);
+	_aligned_free(p);
 #elif defined(LL_DARWIN)
 	return free(p);
 #else
 	free(p); // posix_memalign() is compatible with heap deallocator
 #endif
 }
+#else // USE_TCMALLOC
+// ll_aligned_foo_16 are not needed with tcmalloc
+#define ll_aligned_malloc_16 malloc
+#define ll_aligned_realloc_16 realloc
+#define ll_aligned_free_16 free
+#endif // USE_TCMALLOC
 
 inline void* ll_aligned_malloc_32(size_t size) // returned hunk MUST be freed with ll_aligned_free_32().
 {
 #if defined(LL_WINDOWS)
-	return _mm_malloc(size, 32);
+	return _aligned_malloc(size, 32);
 #elif defined(LL_DARWIN)
 	return ll_aligned_malloc( size, 32 );
 #else
@@ -87,22 +104,13 @@ inline void* ll_aligned_malloc_32(size_t size) // returned hunk MUST be freed wi
 inline void ll_aligned_free_32(void *p)
 {
 #if defined(LL_WINDOWS)
-	_mm_free(p);
+	_aligned_free(p);
 #elif defined(LL_DARWIN)
 	ll_aligned_free( p );
 #else
 	free(p); // posix_memalign() is compatible with heap deallocator
 #endif
 }
-#else // LL_DEBUG
-// ll_aligned_foo are noops now that we use tcmalloc everywhere (tcmalloc aligns automatically at appropriate intervals)
-#define ll_aligned_malloc( size, align ) malloc(size)
-#define ll_aligned_free( ptr ) free(ptr)
-#define ll_aligned_malloc_16 malloc
-#define ll_aligned_free_16 free
-#define ll_aligned_malloc_32 malloc
-#define ll_aligned_free_32 free
-#endif // LL_DEBUG
 
 #ifndef __DEBUG_PRIVATE_MEM__
 #define __DEBUG_PRIVATE_MEM__  0
@@ -512,4 +520,13 @@ void  LLPrivateMemoryPoolTester::operator delete[](void* addr)
 
 // LLSingleton moved to llsingleton.h
 
+LL_COMMON_API void ll_assert_aligned_func(uintptr_t ptr,U32 alignment);
+
+#ifdef SHOW_ASSERT
+#define ll_assert_aligned(ptr,alignment) ll_assert_aligned_func(reinterpret_cast<uintptr_t>(ptr),((U32)alignment))
+#else
+#define ll_assert_aligned(ptr,alignment)
+#endif
+
+
 #endif
diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index affa040602..88c09c8dca 100644
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -140,6 +140,10 @@ public:
 	}
 
 protected:
+#ifdef LL_LIBRARY_INCLUDE
+	void ref();                             
+	void unref();
+#else
 	void ref()                             
 	{ 
 		if (mPointer)
@@ -162,7 +166,7 @@ protected:
 			}
 		}
 	}
-
+#endif
 protected:
 	Type*	mPointer;
 };
diff --git a/indra/llcommon/llsdserialize.cpp b/indra/llcommon/llsdserialize.cpp
index b419101b7e..7f4f670ed0 100644
--- a/indra/llcommon/llsdserialize.cpp
+++ b/indra/llcommon/llsdserialize.cpp
@@ -55,6 +55,10 @@ static const char LEGACY_NON_HEADER[] = "<llsd>";
 const std::string LLSD_BINARY_HEADER("LLSD/Binary");
 const std::string LLSD_XML_HEADER("LLSD/XML");
 
+//used to deflate a gzipped asset (currently used for navmeshes)
+#define windowBits 15
+#define ENABLE_ZLIB_GZIP 32
+
 /**
  * LLSDSerialize
  */
@@ -2096,7 +2100,7 @@ bool unzip_llsd(LLSD& data, std::istream& is, S32 size)
 	strm.next_in = in;
 
 	S32 ret = inflateInit(&strm);
-
+	
 	do
 	{
 		strm.avail_out = CHUNK;
@@ -2159,12 +2163,87 @@ bool unzip_llsd(LLSD& data, std::istream& is, S32 size)
 			llwarns << "Failed to unzip LLSD block" << llendl;
 			free(result);
 			return false;
-		}
+		}		
 	}
 
 	free(result);
 	return true;
 }
+//This unzip function will only work with a gzip header and trailer - while the contents
+//of the actual compressed data is the same for either format (gzip vs zlib ), the headers
+//and trailers are different for the formats.
+U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32 size )
+{
+	U8* result = NULL;
+	U32 cur_size = 0;
+	z_stream strm;
+		
+	const U32 CHUNK = 0x4000;
 
+	U8 *in = new U8[size];
+	is.read((char*) in, size); 
+
+	U8 out[CHUNK];
+		
+	strm.zalloc = Z_NULL;
+	strm.zfree = Z_NULL;
+	strm.opaque = Z_NULL;
+	strm.avail_in = size;
+	strm.next_in = in;
+
+	
+	S32 ret = inflateInit2(&strm,  windowBits | ENABLE_ZLIB_GZIP );
+	do
+	{
+		strm.avail_out = CHUNK;
+		strm.next_out = out;
+		ret = inflate(&strm, Z_NO_FLUSH);
+		if (ret == Z_STREAM_ERROR)
+		{
+			inflateEnd(&strm);
+			free(result);
+			delete [] in;
+			valid = false;
+		}
+		
+		switch (ret)
+		{
+		case Z_NEED_DICT:
+			ret = Z_DATA_ERROR;
+		case Z_DATA_ERROR:
+		case Z_MEM_ERROR:
+			inflateEnd(&strm);
+			free(result);
+			delete [] in;
+			valid = false;
+			break;
+		}
+
+		U32 have = CHUNK-strm.avail_out;
+
+		result = (U8*) realloc(result, cur_size + have);
+		memcpy(result+cur_size, out, have);
+		cur_size += have;
+
+	} while (ret == Z_OK);
+
+	inflateEnd(&strm);
+	delete [] in;
+
+	if (ret != Z_STREAM_END)
+	{
+		free(result);
+		valid = false;
+		return NULL;
+	}
+
+	//result now points to the decompressed LLSD block
+	{
+		outsize= cur_size;
+		valid = true;		
+	}
+
+	return result;
+}
 
 
diff --git a/indra/llcommon/llsdserialize.h b/indra/llcommon/llsdserialize.h
index 99a3ea3cd4..86e3fc864c 100644
--- a/indra/llcommon/llsdserialize.h
+++ b/indra/llcommon/llsdserialize.h
@@ -793,5 +793,5 @@ public:
 //dirty little zip functions -- yell at davep
 LL_COMMON_API std::string zip_llsd(LLSD& data);
 LL_COMMON_API bool unzip_llsd(LLSD& data, std::istream& is, S32 size);
-
+LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize,std::istream& is, S32 size);
 #endif // LL_LLSDSERIALIZE_H
diff --git a/indra/llcommon/llstatenums.h b/indra/llcommon/llstatenums.h
index 9033d8eb43..81c4085d16 100644
--- a/indra/llcommon/llstatenums.h
+++ b/indra/llcommon/llstatenums.h
@@ -28,41 +28,48 @@
 
 enum
 {
-	LL_SIM_STAT_TIME_DILATION,				// 0
-	LL_SIM_STAT_FPS,
-	LL_SIM_STAT_PHYSFPS,
-	LL_SIM_STAT_AGENTUPS,
-	LL_SIM_STAT_FRAMEMS,
-	LL_SIM_STAT_NETMS,						// 5
-	LL_SIM_STAT_SIMOTHERMS,
-	LL_SIM_STAT_SIMPHYSICSMS,
-	LL_SIM_STAT_AGENTMS,
-	LL_SIM_STAT_IMAGESMS,
-	LL_SIM_STAT_SCRIPTMS,					// 10
-	LL_SIM_STAT_NUMTASKS,
-	LL_SIM_STAT_NUMTASKSACTIVE,
-	LL_SIM_STAT_NUMAGENTMAIN,
-	LL_SIM_STAT_NUMAGENTCHILD,
-	LL_SIM_STAT_NUMSCRIPTSACTIVE,			// 15
-	LL_SIM_STAT_LSLIPS,
-	LL_SIM_STAT_INPPS,
-	LL_SIM_STAT_OUTPPS,
-	LL_SIM_STAT_PENDING_DOWNLOADS,
-	LL_SIM_STAT_PENDING_UPLOADS,			// 20
-	LL_SIM_STAT_VIRTUAL_SIZE_KB,
-	LL_SIM_STAT_RESIDENT_SIZE_KB,
-	LL_SIM_STAT_PENDING_LOCAL_UPLOADS,
-	LL_SIM_STAT_TOTAL_UNACKED_BYTES,
-	LL_SIM_STAT_PHYSICS_PINNED_TASKS,		// 25
-	LL_SIM_STAT_PHYSICS_LOD_TASKS,
-	LL_SIM_STAT_SIMPHYSICSSTEPMS,
-	LL_SIM_STAT_SIMPHYSICSSHAPEMS,
-	LL_SIM_STAT_SIMPHYSICSOTHERMS,
-	LL_SIM_STAT_SIMPHYSICSMEMORY,			// 30
-	LL_SIM_STAT_SCRIPT_EPS,
-	LL_SIM_STAT_SIMSPARETIME,
-	LL_SIM_STAT_SIMSLEEPTIME,
-	LL_SIM_STAT_IOPUMPTIME,
+	LL_SIM_STAT_TIME_DILATION         =  0,
+	LL_SIM_STAT_FPS                   =  1,
+	LL_SIM_STAT_PHYSFPS               =  2,
+	LL_SIM_STAT_AGENTUPS              =  3,
+	LL_SIM_STAT_FRAMEMS               =  4,
+	LL_SIM_STAT_NETMS                 =  5,
+	LL_SIM_STAT_SIMOTHERMS            =  6,
+	LL_SIM_STAT_SIMPHYSICSMS          =  7,
+	LL_SIM_STAT_AGENTMS               =  8,
+	LL_SIM_STAT_IMAGESMS              =  9,
+	LL_SIM_STAT_SCRIPTMS              = 10,
+	LL_SIM_STAT_NUMTASKS              = 11,
+	LL_SIM_STAT_NUMTASKSACTIVE        = 12,
+	LL_SIM_STAT_NUMAGENTMAIN          = 13,
+	LL_SIM_STAT_NUMAGENTCHILD         = 14,
+	LL_SIM_STAT_NUMSCRIPTSACTIVE      = 15,
+	LL_SIM_STAT_LSLIPS                = 16,
+	LL_SIM_STAT_INPPS                 = 17,
+	LL_SIM_STAT_OUTPPS                = 18,
+	LL_SIM_STAT_PENDING_DOWNLOADS     = 19,
+	LL_SIM_STAT_PENDING_UPLOADS       = 20,
+	LL_SIM_STAT_VIRTUAL_SIZE_KB       = 21,
+	LL_SIM_STAT_RESIDENT_SIZE_KB      = 22,
+	LL_SIM_STAT_PENDING_LOCAL_UPLOADS = 23,
+	LL_SIM_STAT_TOTAL_UNACKED_BYTES   = 24,
+	LL_SIM_STAT_PHYSICS_PINNED_TASKS  = 25,
+	LL_SIM_STAT_PHYSICS_LOD_TASKS     = 26,
+	LL_SIM_STAT_SIMPHYSICSSTEPMS      = 27,
+	LL_SIM_STAT_SIMPHYSICSSHAPEMS     = 28,
+	LL_SIM_STAT_SIMPHYSICSOTHERMS     = 29,
+	LL_SIM_STAT_SIMPHYSICSMEMORY      = 30,
+	LL_SIM_STAT_SCRIPT_EPS            = 31,
+	LL_SIM_STAT_SIMSPARETIME          = 32,
+	LL_SIM_STAT_SIMSLEEPTIME          = 33,
+	LL_SIM_STAT_IOPUMPTIME            = 34,
+	LL_SIM_STAT_PCTSCRIPTSRUN         = 35,
+	LL_SIM_STAT_REGION_IDLE           = 36, // dataserver only
+	LL_SIM_STAT_REGION_IDLE_POSSIBLE  = 37, // dataserver only
+	LL_SIM_STAT_SIMAISTEPTIMEMS       = 38,
+	LL_SIM_STAT_SKIPPEDAISILSTEPS_PS  = 39,
+	LL_SIM_STAT_PCTSTEPPEDCHARACTERS  = 40
+
 };
 
 #endif
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 09733e8e2a..119efc7957 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -183,6 +183,9 @@ public:
 	static bool isPunct(char a) { return ispunct((unsigned char)a) != 0; }
 	static bool isPunct(llwchar a) { return iswpunct(a) != 0; }
 
+	static bool isAlpha(char a) { return isalpha((unsigned char)a) != 0; }
+	static bool isAlpha(llwchar a) { return iswalpha(a) != 0; }
+
 	static bool isAlnum(char a) { return isalnum((unsigned char)a) != 0; }
 	static bool isAlnum(llwchar a) { return iswalnum(a) != 0; }
 
diff --git a/indra/llcommon/lluuid.cpp b/indra/llcommon/lluuid.cpp
index 5d452ac4e4..db8c9c85ab 100644
--- a/indra/llcommon/lluuid.cpp
+++ b/indra/llcommon/lluuid.cpp
@@ -922,3 +922,174 @@ LLAssetID LLTransactionID::makeAssetID(const LLUUID& session) const
 	}
 	return result;
 }
+
+// Construct
+LLUUID::LLUUID()
+{
+	setNull();
+}
+
+
+// Faster than copying from memory
+ void LLUUID::setNull()
+{
+	U32 *word = (U32 *)mData;
+	word[0] = 0;
+	word[1] = 0;
+	word[2] = 0;
+	word[3] = 0;
+}
+
+
+// Compare
+ bool LLUUID::operator==(const LLUUID& rhs) const
+{
+	U32 *tmp = (U32 *)mData;
+	U32 *rhstmp = (U32 *)rhs.mData;
+	// Note: binary & to avoid branching
+	return 
+		(tmp[0] == rhstmp[0]) &  
+		(tmp[1] == rhstmp[1]) &
+		(tmp[2] == rhstmp[2]) &
+		(tmp[3] == rhstmp[3]);
+}
+
+
+ bool LLUUID::operator!=(const LLUUID& rhs) const
+{
+	U32 *tmp = (U32 *)mData;
+	U32 *rhstmp = (U32 *)rhs.mData;
+	// Note: binary | to avoid branching
+	return 
+		(tmp[0] != rhstmp[0]) |
+		(tmp[1] != rhstmp[1]) |
+		(tmp[2] != rhstmp[2]) |
+		(tmp[3] != rhstmp[3]);
+}
+
+/*
+// JC: This is dangerous.  It allows UUIDs to be cast automatically
+// to integers, among other things.  Use isNull() or notNull().
+ LLUUID::operator bool() const
+{
+	U32 *word = (U32 *)mData;
+	return (word[0] | word[1] | word[2] | word[3]) > 0;
+}
+*/
+
+ BOOL LLUUID::notNull() const
+{
+	U32 *word = (U32 *)mData;
+	return (word[0] | word[1] | word[2] | word[3]) > 0;
+}
+
+// Faster than == LLUUID::null because doesn't require
+// as much memory access.
+ BOOL LLUUID::isNull() const
+{
+	U32 *word = (U32 *)mData;
+	// If all bits are zero, return !0 == TRUE
+	return !(word[0] | word[1] | word[2] | word[3]);
+}
+
+// Copy constructor
+ LLUUID::LLUUID(const LLUUID& rhs)
+{
+	U32 *tmp = (U32 *)mData;
+	U32 *rhstmp = (U32 *)rhs.mData;
+	tmp[0] = rhstmp[0];
+	tmp[1] = rhstmp[1];
+	tmp[2] = rhstmp[2];
+	tmp[3] = rhstmp[3];
+}
+
+ LLUUID::~LLUUID()
+{
+}
+
+// Assignment
+ LLUUID& LLUUID::operator=(const LLUUID& rhs)
+{
+	// No need to check the case where this==&rhs.  The branch is slower than the write.
+	U32 *tmp = (U32 *)mData;
+	U32 *rhstmp = (U32 *)rhs.mData;
+	tmp[0] = rhstmp[0];
+	tmp[1] = rhstmp[1];
+	tmp[2] = rhstmp[2];
+	tmp[3] = rhstmp[3];
+	
+	return *this;
+}
+
+
+ LLUUID::LLUUID(const char *in_string)
+{
+	if (!in_string || in_string[0] == 0)
+	{
+		setNull();
+		return;
+	}
+ 
+	set(in_string);
+}
+
+ LLUUID::LLUUID(const std::string& in_string)
+{
+	if (in_string.empty())
+	{
+		setNull();
+		return;
+	}
+
+	set(in_string);
+}
+
+// IW: DON'T "optimize" these w/ U32s or you'll scoogie the sort order
+// IW: this will make me very sad
+ bool LLUUID::operator<(const LLUUID &rhs) const
+{
+	U32 i;
+	for( i = 0; i < (UUID_BYTES - 1); i++ )
+	{
+		if( mData[i] != rhs.mData[i] )
+		{
+			return (mData[i] < rhs.mData[i]);
+		}
+	}
+	return (mData[UUID_BYTES - 1] < rhs.mData[UUID_BYTES - 1]);
+}
+
+ bool LLUUID::operator>(const LLUUID &rhs) const
+{
+	U32 i;
+	for( i = 0; i < (UUID_BYTES - 1); i++ )
+	{
+		if( mData[i] != rhs.mData[i] )
+		{
+			return (mData[i] > rhs.mData[i]);
+		}
+	}
+	return (mData[UUID_BYTES - 1] > rhs.mData[UUID_BYTES - 1]);
+}
+
+ U16 LLUUID::getCRC16() const
+{
+	// A UUID is 16 bytes, or 8 shorts.
+	U16 *short_data = (U16*)mData;
+	U16 out = 0;
+	out += short_data[0];
+	out += short_data[1];
+	out += short_data[2];
+	out += short_data[3];
+	out += short_data[4];
+	out += short_data[5];
+	out += short_data[6];
+	out += short_data[7];
+	return out;
+}
+
+ U32 LLUUID::getCRC32() const
+{
+	U32 *tmp = (U32*)mData;
+	return tmp[0] + tmp[1] + tmp[2] + tmp[3];
+}
diff --git a/indra/llcommon/lluuid.h b/indra/llcommon/lluuid.h
index 726be4a82d..0b9e7d0cd0 100644
--- a/indra/llcommon/lluuid.h
+++ b/indra/llcommon/lluuid.h
@@ -129,177 +129,6 @@ public:
 
 typedef std::vector<LLUUID> uuid_vec_t;
 
-// Construct
-inline LLUUID::LLUUID()
-{
-	setNull();
-}
-
-
-// Faster than copying from memory
-inline void LLUUID::setNull()
-{
-	U32 *word = (U32 *)mData;
-	word[0] = 0;
-	word[1] = 0;
-	word[2] = 0;
-	word[3] = 0;
-}
-
-
-// Compare
-inline bool LLUUID::operator==(const LLUUID& rhs) const
-{
-	U32 *tmp = (U32 *)mData;
-	U32 *rhstmp = (U32 *)rhs.mData;
-	// Note: binary & to avoid branching
-	return 
-		(tmp[0] == rhstmp[0]) &  
-		(tmp[1] == rhstmp[1]) &
-		(tmp[2] == rhstmp[2]) &
-		(tmp[3] == rhstmp[3]);
-}
-
-
-inline bool LLUUID::operator!=(const LLUUID& rhs) const
-{
-	U32 *tmp = (U32 *)mData;
-	U32 *rhstmp = (U32 *)rhs.mData;
-	// Note: binary | to avoid branching
-	return 
-		(tmp[0] != rhstmp[0]) |
-		(tmp[1] != rhstmp[1]) |
-		(tmp[2] != rhstmp[2]) |
-		(tmp[3] != rhstmp[3]);
-}
-
-/*
-// JC: This is dangerous.  It allows UUIDs to be cast automatically
-// to integers, among other things.  Use isNull() or notNull().
-inline LLUUID::operator bool() const
-{
-	U32 *word = (U32 *)mData;
-	return (word[0] | word[1] | word[2] | word[3]) > 0;
-}
-*/
-
-inline BOOL LLUUID::notNull() const
-{
-	U32 *word = (U32 *)mData;
-	return (word[0] | word[1] | word[2] | word[3]) > 0;
-}
-
-// Faster than == LLUUID::null because doesn't require
-// as much memory access.
-inline BOOL LLUUID::isNull() const
-{
-	U32 *word = (U32 *)mData;
-	// If all bits are zero, return !0 == TRUE
-	return !(word[0] | word[1] | word[2] | word[3]);
-}
-
-// Copy constructor
-inline LLUUID::LLUUID(const LLUUID& rhs)
-{
-	U32 *tmp = (U32 *)mData;
-	U32 *rhstmp = (U32 *)rhs.mData;
-	tmp[0] = rhstmp[0];
-	tmp[1] = rhstmp[1];
-	tmp[2] = rhstmp[2];
-	tmp[3] = rhstmp[3];
-}
-
-inline LLUUID::~LLUUID()
-{
-}
-
-// Assignment
-inline LLUUID& LLUUID::operator=(const LLUUID& rhs)
-{
-	// No need to check the case where this==&rhs.  The branch is slower than the write.
-	U32 *tmp = (U32 *)mData;
-	U32 *rhstmp = (U32 *)rhs.mData;
-	tmp[0] = rhstmp[0];
-	tmp[1] = rhstmp[1];
-	tmp[2] = rhstmp[2];
-	tmp[3] = rhstmp[3];
-	
-	return *this;
-}
-
-
-inline LLUUID::LLUUID(const char *in_string)
-{
-	if (!in_string || in_string[0] == 0)
-	{
-		setNull();
-		return;
-	}
- 
-	set(in_string);
-}
-
-inline LLUUID::LLUUID(const std::string& in_string)
-{
-	if (in_string.empty())
-	{
-		setNull();
-		return;
-	}
-
-	set(in_string);
-}
-
-// IW: DON'T "optimize" these w/ U32s or you'll scoogie the sort order
-// IW: this will make me very sad
-inline bool LLUUID::operator<(const LLUUID &rhs) const
-{
-	U32 i;
-	for( i = 0; i < (UUID_BYTES - 1); i++ )
-	{
-		if( mData[i] != rhs.mData[i] )
-		{
-			return (mData[i] < rhs.mData[i]);
-		}
-	}
-	return (mData[UUID_BYTES - 1] < rhs.mData[UUID_BYTES - 1]);
-}
-
-inline bool LLUUID::operator>(const LLUUID &rhs) const
-{
-	U32 i;
-	for( i = 0; i < (UUID_BYTES - 1); i++ )
-	{
-		if( mData[i] != rhs.mData[i] )
-		{
-			return (mData[i] > rhs.mData[i]);
-		}
-	}
-	return (mData[UUID_BYTES - 1] > rhs.mData[UUID_BYTES - 1]);
-}
-
-inline U16 LLUUID::getCRC16() const
-{
-	// A UUID is 16 bytes, or 8 shorts.
-	U16 *short_data = (U16*)mData;
-	U16 out = 0;
-	out += short_data[0];
-	out += short_data[1];
-	out += short_data[2];
-	out += short_data[3];
-	out += short_data[4];
-	out += short_data[5];
-	out += short_data[6];
-	out += short_data[7];
-	return out;
-}
-
-inline U32 LLUUID::getCRC32() const
-{
-	U32 *tmp = (U32*)mData;
-	return tmp[0] + tmp[1] + tmp[2] + tmp[3];
-}
-
 
 // Helper structure for ordering lluuids in stl containers.
 // eg: 	std::map<LLUUID, LLWidget*, lluuid_less> widget_map;
@@ -329,3 +158,5 @@ public:
 };
 
 #endif
+
+
diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h
index bfb30f900f..bcc661a920 100644
--- a/indra/llcommon/llversionviewer.h
+++ b/indra/llcommon/llversionviewer.h
@@ -28,8 +28,8 @@
 #define LL_LLVERSIONVIEWER_H
 
 const S32 LL_VERSION_MAJOR = 3;
-const S32 LL_VERSION_MINOR = 3;
-const S32 LL_VERSION_PATCH = 3;
+const S32 LL_VERSION_MINOR = 4;
+const S32 LL_VERSION_PATCH = 1;
 const S32 LL_VERSION_BUILD = 0;
 
 const char * const LL_CHANNEL = "Second Life Developer";