Shyotl's old llcurl

Conflicts:
	indra/newview/llvieweraudio.cpp

indra/CMakeLists.txt

@@ -77,7 +77,6 @@ if (VIEWER)
   add_subdirectory(${LIBS_OPEN_PREFIX}llcrashlogger)
   add_subdirectory(${LIBS_OPEN_PREFIX}llplugin)
   add_subdirectory(${LIBS_OPEN_PREFIX}llui)
-  add_subdirectory(${LIBS_OPEN_PREFIX}llxuixml)
 
   # viewer plugins directory
   add_subdirectory(${LIBS_OPEN_PREFIX}plugins)

indra/cmake/00-Common.cmake

@@ -190,10 +190,10 @@ if (LINUX)
     endif (NOT STANDALONE)
     if (${ARCH} STREQUAL "x86_64")
       add_definitions(-DLINUX64=1 -pipe)
-      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer -ffast-math -funroll-loops")
-      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -fomit-frame-pointer -ffast-math -funroll-loops")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ffast-math")
-      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -ffast-math")
     else (${ARCH} STREQUAL "x86_64")
       if (NOT STANDALONE)
         set(MARCH_FLAG " -march=pentium4")
@@ -269,6 +269,7 @@ if (DARWIN)
   add_definitions(-DLL_DARWIN=1 -D_XOPEN_SOURCE)
   set(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names,-search_paths_first")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_CXX_LINK_FLAGS}")
+  if(${CMAKE_C_COMPILER} MATCHES "gcc*")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mlong-branch")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mlong-branch")
     # NOTE: it's critical that the optimization flag is put in front.
@@ -277,6 +278,14 @@ if (DARWIN)
     set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
     set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  elseif(${CMAKE_C_COMPILER} MATCHES "clang*")
+    # NOTE: it's critical that the optimization flag is put in front.
+    # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered.
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3")
+  endif()
 endif (DARWIN)
 
 
@@ -318,7 +327,7 @@ else (STANDALONE)
       glib-2.0
       gstreamer-0.10
       gtk-2.0
-      llfreetype2
+      freetype2
       pango-1.0
       )
 endif (STANDALONE)

indra/cmake/APR.cmake

@@ -33,8 +33,8 @@ else (STANDALONE)
       optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libapr-1.0.dylib
       )
     set(APRUTIL_LIBRARIES 
-      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libaprutil-1.0.dylib
+      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libaprutil-1.dylib
-      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libaprutil-1.0.dylib
+      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libaprutil-1.dylib
       )
     set(APRICONV_LIBRARIES iconv)
   else (WINDOWS)

indra/cmake/Boost.cmake

@@ -40,10 +40,10 @@ else (STANDALONE)
           debug libboost_regex-vc${MSVC_SUFFIX}-${BOOST_DEBUG_SUFFIX}-${BOOST_VERSION})
 	
   elseif (DARWIN)
-    set(BOOST_FILESYSTEM_LIBRARY boost_filesystem-mt)
+    set(BOOST_FILESYSTEM_LIBRARY boost_filesystem)
-    set(BOOST_PROGRAM_OPTIONS_LIBRARY boost_program_options-mt)
+    set(BOOST_PROGRAM_OPTIONS_LIBRARY boost_program_options)
-    set(BOOST_REGEX_LIBRARY boost_regex-mt)
+    set(BOOST_REGEX_LIBRARY boost_regex)
-    set(BOOST_SYSTEM_LIBRARY boost_system-mt)  
+    set(BOOST_SYSTEM_LIBRARY boost_system)  
   elseif (LINUX)
     set(BOOST_FILESYSTEM_LIBRARY boost_filesystem-mt)
     set(BOOST_PROGRAM_OPTIONS_LIBRARY boost_program_options-mt)

indra/cmake/CURL.cmake

@@ -14,6 +14,9 @@ else (STANDALONE)
     optimized libcurl)
   else (WINDOWS)
     set(CURL_LIBRARIES curl)
+    if(LINUX AND WORD_SIZE EQUAL 64)
+      list(APPEND CURL_LIBRARIES idn)
+    endif(LINUX AND WORD_SIZE EQUAL 64)
   endif (WINDOWS)
   set(CURL_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include)
 endif (STANDALONE)

indra/cmake/FMODEX.cmake

@@ -18,7 +18,7 @@ if (NOT FMODEX_LIBRARY)
   set(FMODEX_SDK_DIR CACHE PATH "Path to the FMOD Ex SDK.")
   if (FMODEX_SDK_DIR)
     find_library(FMODEX_LIBRARY
-                 fmodex fmodex_vc fmodexL_vc
+                 fmodex_vc fmodexL_vc fmodex fmodexL fmodex64 fmodexL64
                  PATHS
                  ${FMODEX_SDK_DIR}/api/lib
                  ${FMODEX_SDK_DIR}/api

indra/cmake/GooglePerfTools.cmake

@@ -1,12 +1,16 @@
 # -*- cmake -*-
 include(Prebuilt)
 
+if(WORD_SIZE EQUAL 64)
+  set(DISABLE_TCMALLOC TRUE)
+endif(WORD_SIZE EQUAL 64)
+
 if (STANDALONE)
   include(FindGooglePerfTools)
 else (STANDALONE)
-  if (LINUX OR WINDOWS)
+  if (LINUX OR WINDOWS AND NOT WORD_SIZE EQUAL 64)
     use_prebuilt_binary(gperftools)
-  endif (LINUX OR WINDOWS)
+  endif (LINUX OR WINDOWS AND NOT WORD_SIZE EQUAL 64)
   if (WINDOWS)
     set(TCMALLOC_LIBRARIES libtcmalloc_minimal.lib)
     set(TCMALLOC_LINKER_FLAGS "/INCLUDE:\"__tcmalloc\"")

indra/cmake/Hunspell.cmake

@@ -6,7 +6,7 @@ if (STANDALONE)
 else (STANDALONE)
     use_prebuilt_binary(hunspell)
 	
-	set(HUNSPELL_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/include/hunspell)
+	set(HUNSPELL_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/hunspell)
 
 	if (LINUX OR DARWIN)
 	    set(HUNSPELL_LIBRARY hunspell-1.3)

indra/cmake/JPEG.cmake

@@ -13,8 +13,8 @@ else (STANDALONE)
     set(JPEG_LIBRARIES jpeg)
   elseif (DARWIN)
     set(JPEG_LIBRARIES
-      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/liblljpeg.a
+      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libjpeg.a
-      debug ${ARCH_PREBUILT_DIRS_DEBUG}/liblljpeg.a
+      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libjpeg.a
       )
   elseif (WINDOWS)
     set(JPEG_LIBRARIES jpeglib)

indra/cmake/JsonCpp.cmake

@@ -14,7 +14,7 @@ else (STANDALONE)
       debug json_vc${MSVC_SUFFIX}d
       optimized json_vc${MSVC_SUFFIX})
   elseif (DARWIN)
-    set(JSONCPP_LIBRARIES json_mac-universal-gcc_libmt)
+    set(JSONCPP_LIBRARIES json_linux-gcc-4.0.1_libmt)
   elseif (LINUX)
     set(JSONCPP_LIBRARIES jsoncpp)
   endif (WINDOWS)

indra/cmake/LLWindow.cmake

@@ -18,7 +18,11 @@ else (STANDALONE)
     use_prebuilt_binary(SDL)
     set (SDL_FOUND TRUE)
     set (SDL_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR})
+    if(WORD_SIZE EQUAL 64)
+      set (SDL_LIBRARY SDL)
+    else(WORD_SIZE EQUAL 64)
       set (SDL_LIBRARY SDL directfb fusion direct)
+    endif(WORD_SIZE EQUAL 64)
   endif (LINUX)
 endif (STANDALONE)
 

indra/cmake/LLXUIXML.cmake

@@ -1,7 +0,0 @@
-# -*- cmake -*-
-
-set(LLXUIXML_INCLUDE_DIRS
-    ${LIBS_OPEN_DIR}/llxuixml
-    )
-
-set(LLXUIXML_LIBRARIES llxuixml)

indra/cmake/Linking.cmake

@@ -10,9 +10,9 @@ if (NOT STANDALONE)
     set(ARCH_PREBUILT_DIRS_RELEASE ${ARCH_PREBUILT_DIRS})
     set(ARCH_PREBUILT_DIRS_DEBUG ${ARCH_PREBUILT_DIRS})
   elseif (DARWIN)
-    set(ARCH_PREBUILT_DIRS_RELEASE ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib_release)
+    set(ARCH_PREBUILT_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib)
-    set(ARCH_PREBUILT_DIRS ${ARCH_PREBUILT_DIRS_RELEASE})
+    set(ARCH_PREBUILT_DIRS_RELEASE ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/release)
-    set(ARCH_PREBUILT_DIRS_DEBUG ${ARCH_PREBUILT_DIRS_RELEASE})
+    set(ARCH_PREBUILT_DIRS_DEBUG ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/debug)
   endif (WINDOWS)
 endif (NOT STANDALONE)
 

indra/cmake/OpenSSL.cmake

@@ -16,8 +16,6 @@ else (STANDALONE)
   set(OPENSSL_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include)
 endif (STANDALONE)
 
-if (LINUX)
+if (LINUX OR DARWIN)
   set(CRYPTO_LIBRARIES crypto)
-elseif (DARWIN)
+endif (LINUX OR DARWIN)
-  set(CRYPTO_LIBRARIES llcrypto)
-endif (LINUX)

indra/cmake/PNG.cmake

@@ -15,5 +15,5 @@ else (STANDALONE)
   else(LINUX)
     set(PNG_LIBRARIES png15)
   endif()
-  set(PNG_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/libpng15)
+  set(PNG_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/)
 endif (STANDALONE)

indra/cmake/Variables.cmake

@@ -76,37 +76,36 @@ endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   set(DARWIN 1)
 
+  if(${CMAKE_GENERATOR} MATCHES Xcode) 
     #SDK Compiler and Deployment targets for XCode
     if (${XCODE_VERSION} VERSION_LESS 4.0.0)
       set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.5.sdk)
+      set(CMAKE_OSX_DEPLOYMENT_TARGET 10.5)
       set(CMAKE_XCODE_ATTIBUTE_GCC_VERSION "4.2")
     else (${XCODE_VERSION} VERSION_LESS 4.0.0)
       set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk)
+      set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
       set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42")
     endif (${XCODE_VERSION} VERSION_LESS 4.0.0)
+  else()
+    set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+    set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42")
+  endif(${CMAKE_GENERATOR} MATCHES Xcode)
 
-  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.5)
+  ## We currently support only 32-bit i386 builds, so use these:
-
-  # NOTE: To attempt an i386/PPC Universal build, add this on the configure line:
-  # -DCMAKE_OSX_ARCHITECTURES:STRING='i386;ppc'
-  # Build only for i386 by default, system default on MacOSX 10.6 is x86_64
-  if (NOT CMAKE_OSX_ARCHITECTURES)
   set(CMAKE_OSX_ARCHITECTURES i386)
-  endif (NOT CMAKE_OSX_ARCHITECTURES)
-
-  if (CMAKE_OSX_ARCHITECTURES MATCHES "i386" AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc")
-    set(ARCH universal)
-  else (CMAKE_OSX_ARCHITECTURES MATCHES "i386" AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc")
-    if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc")
-      set(ARCH ppc)
-    else (${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc")
   set(ARCH i386)
-    endif (${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc")
+  set(WORD_SIZE 32)
-  endif (CMAKE_OSX_ARCHITECTURES MATCHES "i386" AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc")
 
+  ## But if you want to compile for mixed 32/64 bit, try these:
+  # set(CMAKE_OSX_ARCHITECTURES i386;x86_64)
+  # set(ARCH universal)
+  # set(WORD_SIZE 64)
+
+  ## Finally, set up the build output directories
   set(LL_ARCH ${ARCH}_darwin)
   set(LL_ARCH_DIR universal-darwin)
-  set(WORD_SIZE 32)
 endif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 
 

indra/llaudio/llaudioengine.h

@@ -43,11 +43,11 @@
 #include "lluuid.h"
 #include "llframetimer.h"
 #include "llassettype.h"
+#include "llextendedstatus.h"
 
 #include "lllistener.h"
 
 const F32 LL_WIND_UPDATE_INTERVAL = 0.1f;
-const F32 LL_ROLLOFF_MULTIPLIER_UNDER_WATER = 5.f;			//  How much sounds are weaker under water
 const F32 LL_WIND_UNDERWATER_CENTER_FREQ = 20.f;
 
 const F32 ATTACHED_OBJECT_TIMEOUT = 5.0f;

indra/llaudio/llaudioengine_fmodex.cpp

@@ -72,6 +72,8 @@ bool attemptDelayLoad()
 
 FMOD_RESULT F_CALLBACK windCallback(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int outchannels);
 
+FMOD::ChannelGroup *LLAudioEngine_FMODEX::mChannelGroups[LLAudioEngine::AUDIO_TYPE_COUNT] = {0};
+
 LLAudioEngine_FMODEX::LLAudioEngine_FMODEX(bool enable_profiler)
 {
 	mInited = false;
@@ -95,6 +97,28 @@ inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
 	return true;
 }
 
+void* F_STDCALL decode_alloc(unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+	if(type & FMOD_MEMORY_STREAM_DECODE)
+	{
+		llinfos << "Decode buffer size: " << size << llendl;
+	}
+	else if(type & FMOD_MEMORY_STREAM_FILE)
+	{
+		llinfos << "Strean buffer size: " << size << llendl;
+	}
+	return new char[size];
+}
+void* F_STDCALL decode_realloc(void *ptr, unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+	memset(ptr,0,size);
+	return ptr;
+}
+void F_STDCALL decode_dealloc(void *ptr, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+	delete[] (char*)ptr;
+}
+
 bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 {
 
@@ -108,6 +132,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 
 	LL_DEBUGS("AppInit") << "LLAudioEngine_FMODEX::init() initializing FMOD" << LL_ENDL;
 
+	result = FMOD::Memory_Initialize(NULL, 0, &decode_alloc, &decode_realloc, &decode_dealloc, FMOD_MEMORY_STREAM_DECODE | FMOD_MEMORY_STREAM_FILE);
+	if(Check_FMOD_Error(result, "FMOD::Memory_Initialize"))
+		return false;
+
 	result = FMOD::System_Create(&mSystem);
 	if(Check_FMOD_Error(result, "FMOD::System_Create"))
 		return false;
@@ -124,54 +152,8 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 			<< ")!  You should be using FMOD Ex" << FMOD_VERSION << LL_ENDL;
 	}
 
-#if LL_WINDOWS
+	result = mSystem->setSoftwareFormat(44100, FMOD_SOUND_FORMAT_PCM16, 0, 0, FMOD_DSP_RESAMPLER_LINEAR);
-	int numdrivers;
-	FMOD_SPEAKERMODE speakermode;
-	FMOD_CAPS caps;
-	char name[256];
-
-	//Is this block applicable to linux?
-	{
-		result = mSystem->getNumDrivers(&numdrivers);
-		Check_FMOD_Error(result, "FMOD::System::getNumDrivers");
-		if (numdrivers == 0)
-		{
-			result = mSystem->setOutput(FMOD_OUTPUTTYPE_NOSOUND);
-			Check_FMOD_Error(result, "FMOD::System::setOutput");
-		}
-		else
-		{
-			result = mSystem->getDriverCaps(0, &caps, 0, &speakermode);
-			Check_FMOD_Error(result,"FMOD::System::getDriverCaps");
-			/*
-			Set the user selected speaker mode.
-			*/
-			result = mSystem->setSpeakerMode(speakermode);
-			Check_FMOD_Error(result, "FMOD::System::setSpeakerMode");
-			if (caps & FMOD_CAPS_HARDWARE_EMULATED)
-			{
-				/*
-				The user has the 'Acceleration' slider set to off! This is really bad
-				for latency! You might want to warn the user about this.
-				*/
-				result = mSystem->setDSPBufferSize(1024, 10);
-				Check_FMOD_Error(result, "FMOD::System::setDSPBufferSize");
-			}
-			result = mSystem->getDriverInfo(0, name, 256, 0);
-			Check_FMOD_Error(result, "FMOD::System::getDriverInfo");
-
-			if (strstr(name, "SigmaTel"))
-			{
-				/*
-				Sigmatel sound devices crackle for some reason if the format is PCM 16bit.
-				PCM floating point output seems to solve it.
-				*/
-				result = mSystem->setSoftwareFormat(48000, FMOD_SOUND_FORMAT_PCMFLOAT, 0,0, FMOD_DSP_RESAMPLER_LINEAR);
 	Check_FMOD_Error(result,"FMOD::System::setSoftwareFormat");
-			}
-		}
-	}
-#endif //LL_WINDOWS
 
 	// In this case, all sounds, PLUS wind and stream will be software.
 	result = mSystem->setSoftwareChannels(num_channels + 2);
@@ -179,7 +161,13 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 
 	U32 fmod_flags = FMOD_INIT_NORMAL;
 	if(mEnableProfiler)
+	{
 		fmod_flags |= FMOD_INIT_ENABLE_PROFILE;
+		mSystem->createChannelGroup("None", &mChannelGroups[AUDIO_TYPE_NONE]);
+		mSystem->createChannelGroup("SFX", &mChannelGroups[AUDIO_TYPE_SFX]);
+		mSystem->createChannelGroup("UI", &mChannelGroups[AUDIO_TYPE_UI]);
+		mSystem->createChannelGroup("Ambient", &mChannelGroups[AUDIO_TYPE_AMBIENT]);
+	}
 
 #if LL_LINUX
 	bool audio_ok = false;
@@ -297,6 +285,19 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 
 	LL_INFOS("AppInit") << "LLAudioEngine_FMODEX::init() FMOD Ex initialized correctly" << LL_ENDL;
 
+	int r_numbuffers, r_samplerate, r_channels, r_bits;
+	unsigned int r_bufferlength;
+	char r_name[256];
+	mSystem->getDSPBufferSize(&r_bufferlength, &r_numbuffers);
+	mSystem->getSoftwareFormat(&r_samplerate, NULL, &r_channels, NULL, NULL, &r_bits);
+	mSystem->getDriverInfo(0, r_name, 255, 0);
+	r_name[255] = '\0';
+	int latency = 1000.0 * r_bufferlength * r_numbuffers /r_samplerate;
+
+	LL_INFOS("AppInit") << "FMOD device: "<< r_name << "\n"
+		<< "FMOD Ex parameters: " << r_samplerate << " Hz * " << r_channels << " * " <<r_bits <<" bit\n"
+		<< "\tbuffer " << r_bufferlength << " * " << r_numbuffers << " (" << latency <<"ms)" << LL_ENDL;
+
 	mInited = true;
 
 	return true;
@@ -611,6 +612,9 @@ void LLAudioChannelFMODEX::play()
 	Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::pause");
 
 	getSource()->setPlayedOnce(true);
+
+	if(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()])
+		mChannelp->setChannelGroup(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()]);
 }
 
 

indra/llaudio/llaudioengine_fmodex.h

@@ -44,6 +44,7 @@ namespace FMOD
 {
 	class System;
 	class Channel;
+	class ChannelGroup;
 	class Sound;
 	class DSP;
 }
@@ -83,6 +84,9 @@ protected:
 	FMOD::DSP *mWindDSP;
 	FMOD::System *mSystem;
 	bool mEnableProfiler;
+
+public:
+	static FMOD::ChannelGroup *mChannelGroups[LLAudioEngine::AUDIO_TYPE_COUNT];
 };
 
 

indra/llaudio/lllistener_fmodex.cpp

@@ -106,6 +106,15 @@ void LLListener_FMODEX::commitDeferredChanges()
 
 void LLListener_FMODEX::setRolloffFactor(F32 factor)
 {
+	//An internal FMODEx optimization skips 3D updates if there have not been changes to the 3D sound environment.
+	//Sadly, a change in rolloff is not accounted for, thus we must touch the listener properties as well.
+	//In short: Changing the position ticks a dirtyflag inside fmodex, which makes it not skip 3D processing next update call.
+	if(mRolloffFactor != factor)
+	{
+		LLVector3 pos = mVelocity - LLVector3(0.f,0.f,.1f);
+		mSystem->set3DListenerAttributes(0, (FMOD_VECTOR*)pos.mV, NULL, NULL, NULL);
+		mSystem->set3DListenerAttributes(0, (FMOD_VECTOR*)mVelocity.mV, NULL, NULL, NULL);
+	}
 	mRolloffFactor = factor;
 	mSystem->set3DSettings(mDopplerFactor, 1.f, mRolloffFactor);
 }

indra/llaudio/llstreamingaudio.h

@@ -58,6 +58,9 @@ class LLStreamingAudioInterface
 	virtual const LLSD *getMetaData() = 0;
 	virtual bool supportsWaveData() = 0;
 	virtual bool getWaveData(float* arr, S32 count, S32 stride = 1) = 0;
+
+	virtual bool supportsAdjustableBufferSizes(){return false;}
+	virtual void setBufferSizes(U32 streambuffertime, U32 decodebuffertime){};
 };
 
 #endif // LL_STREAMINGAUDIO_H

indra/llaudio/llstreamingaudio_fmodex.cpp

@@ -50,7 +50,7 @@ public:
 
 	const std::string& getURL() 	{ return mInternetStreamURL; }
 
-	FMOD_OPENSTATE getOpenState();
+	FMOD_OPENSTATE getOpenState(unsigned int* percentbuffered=NULL, bool* starving=NULL, bool* diskbusy=NULL);
 protected:
 	FMOD::System* mSystem;
 	FMOD::Channel* mStreamChannel;
@@ -74,7 +74,7 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
 {
 	// Number of milliseconds of audio to buffer for the audio card.
 	// Must be larger than the usual Second Life frame stutter time.
-	const U32 buffer_seconds = 5;		//sec
+	const U32 buffer_seconds = 10;		//sec
 	const U32 estimated_bitrate = 128;	//kbit/sec
 	mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
 
@@ -145,7 +145,10 @@ void LLStreamingAudio_FMODEX::update()
 		return;
 	}
 
-	FMOD_OPENSTATE open_state = mCurrentInternetStreamp->getOpenState();
+	unsigned int progress;
+	bool starving;
+	bool diskbusy;
+	FMOD_OPENSTATE open_state = mCurrentInternetStreamp->getOpenState(&progress, &starving, &diskbusy);
 
 	if (open_state == FMOD_OPENSTATE_READY)
 	{
@@ -158,6 +161,7 @@ void LLStreamingAudio_FMODEX::update()
 			// Reset volume to previously set volume
 			setGain(getGain());
 			mFMODInternetStreamChannelp->setPaused(false);
+			mLastStarved.stop();
 		}
 	}
 	else if(open_state == FMOD_OPENSTATE_ERROR)
@@ -237,12 +241,29 @@ void LLStreamingAudio_FMODEX::update()
 					}
 				}
 			}
+			if(starving)
+			{
+				if(!mLastStarved.getStarted())
+				{
+					llinfos << "Stream starvation detected! Muting stream audio until it clears." << llendl;
+					llinfos << "  (diskbusy="<<diskbusy<<")" << llendl;
+					llinfos << "  (progress="<<progress<<")" << llendl;
+					mFMODInternetStreamChannelp->setMute(true);
+				}
+				mLastStarved.start();
+			}
+			else if(mLastStarved.getStarted() && mLastStarved.getElapsedTimeF32() > 1.f)
+			{
+				mLastStarved.stop();
+				mFMODInternetStreamChannelp->setMute(false);
+			}
 		}
 	}
 }
 
 void LLStreamingAudio_FMODEX::stop()
 {
+	mLastStarved.stop();
 	if(mMetaData)
 	{
 		delete mMetaData;
@@ -341,6 +362,11 @@ void LLStreamingAudio_FMODEX::setGain(F32 vol)
 	if(!mFMODInternetStreamChannelp || !mCurrentInternetStreamp)
 		return false;
 
+	bool muted=false;
+	mFMODInternetStreamChannelp->getMute(&muted);
+	if(muted)
+		return false;
+
 	static std::vector<float> local_array(count);	//Have to have an extra buffer to mix channels. Bleh.
 	if(count > (S32)local_array.size())	//Expand the array if needed. Try to minimize allocation calls, so don't ever shrink.
 		local_array.resize(count);
@@ -442,9 +468,19 @@ bool LLAudioStreamManagerFMODEX::stopStream()
 	}
 }
 
-FMOD_OPENSTATE LLAudioStreamManagerFMODEX::getOpenState()
+FMOD_OPENSTATE LLAudioStreamManagerFMODEX::getOpenState(unsigned int* percentbuffered, bool* starving, bool* diskbusy)
 {
 	FMOD_OPENSTATE state;
-	mInternetStream->getOpenState(&state,NULL,NULL,NULL);
+	mInternetStream->getOpenState(&state,percentbuffered,starving,diskbusy);
 	return state;
 }
+
+void LLStreamingAudio_FMODEX::setBufferSizes(U32 streambuffertime, U32 decodebuffertime)
+{
+	mSystem->setStreamBufferSize(streambuffertime/1000*128*128, FMOD_TIMEUNIT_RAWBYTES);
+	FMOD_ADVANCEDSETTINGS settings;
+	memset(&settings,0,sizeof(settings));
+	settings.cbsize=sizeof(settings);
+	settings.defaultDecodeBufferSize = decodebuffertime;//ms
+	mSystem->setAdvancedSettings(&settings);
+}

indra/llaudio/llstreamingaudio_fmodex.h

@@ -37,6 +37,7 @@
 #include "stdtypes.h" // from llcommon
 
 #include "llstreamingaudio.h"
+#include "lltimer.h"
 
 //Stubs
 class LLAudioStreamManagerFMODEX;
@@ -66,6 +67,8 @@ class LLStreamingAudio_FMODEX : public LLStreamingAudioInterface
 	/*virtual*/ const LLSD *getMetaData(){return mMetaData;}	//return NULL if not playing.
 	/*virtual*/ bool supportsWaveData(){return true;}
 	/*virtual*/ bool getWaveData(float* arr, S32 count, S32 stride = 1);
+	/*virtual*/ bool supportsAdjustableBufferSizes(){return true;}
+	/*virtual*/ void setBufferSizes(U32 streambuffertime, U32 decodebuffertime);
 private:
 	FMOD::System *mSystem;
 
@@ -76,6 +79,8 @@ private:
 	std::string mURL;
 	F32 mGain;
 
+	LLTimer mLastStarved;
+
 	LLSD *mMetaData;
 };
 

indra/llcharacter/llcharacter.cpp

@@ -38,7 +38,6 @@
 
 #include "llcharacter.h"
 #include "llstring.h"
-#include "llfasttimer.h"
 
 #define SKEL_HEADER "Linden Skeleton 1.0"
 

indra/llcharacter/llheadrotmotion.cpp

@@ -250,9 +250,9 @@ BOOL LLHeadRotMotion::onUpdate(F32 time, U8* joint_mask)
 	head_rot_local = nlerp(head_slerp_amt, mLastHeadRot, head_rot_local);
 	mLastHeadRot = head_rot_local;
 
-	if(mNeckState->getJoint() && mNeckState->getJoint()->getParent()) //Guess this has crashed? Taken from snowglobe -Shyotl
-	{
 	// Set the head rotation.
+	if(mNeckState->getJoint() && mNeckState->getJoint()->getParent())
+	{
 		LLQuaternion torsoRotLocal =  mNeckState->getJoint()->getParent()->getWorldRotation() * currentInvRootRotWorld;
 		head_rot_local = head_rot_local * ~torsoRotLocal;
 		mNeckState->setRotation( nlerp(NECK_LAG, LLQuaternion::DEFAULT, head_rot_local) );

indra/llcharacter/llvisualparam.h

@@ -93,6 +93,7 @@ class LLVisualParam
 {
 public:
 	typedef	boost::function<LLVisualParam*(S32)> visual_param_mapper;
+
 	LLVisualParam();
 	virtual ~LLVisualParam();
 

indra/llcommon/CMakeLists.txt

@@ -53,6 +53,7 @@ set(llcommon_SOURCE_FILES
     llformat.cpp
     llframetimer.cpp
     llheartbeat.cpp
+    llinitparam.cpp
     llinstancetracker.cpp
     llindraconfigfile.cpp
     llliveappconfig.cpp
@@ -171,6 +172,7 @@ set(llcommon_HEADER_FILES
     llheartbeat.h
     llhttpstatuscodes.h
     llindexedqueue.h
+    llinitparam.h
     llinstancetracker.h
     llindraconfigfile.h
     llkeythrottle.h
@@ -212,6 +214,7 @@ set(llcommon_HEADER_FILES
     llsingleton.h
     llskiplist.h
     llskipmap.h
+    llsortedvector.h
     llstack.h
     llstacktrace.h
     llstat.h
@@ -226,6 +229,7 @@ set(llcommon_HEADER_FILES
     llthreadsafequeue.h
     lltimer.h
     lltreeiterators.h
+    lltypeinfolookup.h
     lluri.h
     lluuid.h
     lluuidhashmap.h

indra/llcommon/linden_common.h

@@ -33,6 +33,11 @@
 #ifndef LL_LINDEN_COMMON_H
 #define LL_LINDEN_COMMON_H
 
+// *NOTE:  Please keep includes here to a minimum!
+//
+// Files included here are included in every library .cpp file and
+// are not precompiled.
+
 #include "cwdebug.h"
 
 #if defined(LL_WINDOWS) && defined(_DEBUG)
@@ -55,34 +60,11 @@
 #include <ctime>
 #include <iosfwd>
 
-// Work around Microsoft compiler warnings in STL headers
-#ifdef LL_WINDOWS
-#pragma warning (disable : 4702) // unreachable code
-#pragma warning (disable : 4244) // conversion from time_t to S32
-#endif	//	LL_WINDOWS
-
-// *TODO: Eliminate these, most library .cpp files don't need them.
-// Add them to llviewerprecompiledheaders.h if necessary.
-#include <list>
-#include <map>
-#include <vector>
-#include <string>
-
-#ifdef LL_WINDOWS
-// Reenable warnings we disabled above
-#pragma warning (3 : 4702) // unreachable code, we like level 3, not 4
-// moved msvc warnings to llpreprocessor.h  *TODO - delete this comment after merge conflicts are unlikely -brad
-#endif	//	LL_WINDOWS
-
 // Linden only libs in alpha-order other than stdtypes.h
 // *NOTE: Please keep includes here to a minimum, see above.
 #include "stdtypes.h"
 #include "lldefs.h"
 #include "llerror.h"
-#include "llextendedstatus.h"
-// Don't do this, adds 15K lines of header code to every library file.
-//#include "llfasttimer.h"
 #include "llfile.h"
-#include "llformat.h"
 
 #endif

indra/llcommon/llapp.h

@@ -43,10 +43,14 @@ template <typename Type> class LLAtomic32;
 typedef LLAtomic32<U32> LLAtomicU32;
 class LLErrorThread;
 class LLLiveFile;
+
+
 #if LL_LINUX
-typedef struct siginfo siginfo_t;
+	#include <signal.h>
+	//typedef struct siginfo siginfo_t; //Removed as per changes in glibc 2.16 - Drake Arconis
 #endif
 
+
 typedef void (*LLAppErrorHandler)();
 typedef void (*LLAppChildCallback)(int pid, bool exited, int status);
 

indra/llcommon/llinitparam.h

@@ -35,6 +35,7 @@
 #include <boost/shared_ptr.hpp>
 
 #include "llerror.h"
+#include "lltypeinfolookup.h"
 
 namespace LLInitParam
 {
@@ -205,7 +206,7 @@ namespace LLInitParam
 		mutable std::string	mValueName;
 	};
 
-	class Parser
+	class LL_COMMON_API Parser
 	{
 		LOG_CLASS(Parser);
 
@@ -227,9 +228,9 @@ namespace LLInitParam
 		typedef bool (*parser_write_func_t)(Parser& parser, const void*, name_stack_t&);
 		typedef boost::function<void (name_stack_t&, S32, S32, const possible_values_t*)>	parser_inspect_func_t;
 
-		typedef std::map<const std::type_info*, parser_read_func_t, CompareTypeID>		parser_read_func_map_t;
+		typedef LLTypeInfoLookup<parser_read_func_t>		parser_read_func_map_t;
-		typedef std::map<const std::type_info*, parser_write_func_t, CompareTypeID>		parser_write_func_map_t;
+		typedef LLTypeInfoLookup<parser_write_func_t>		parser_write_func_map_t;
-		typedef std::map<const std::type_info*, parser_inspect_func_t, CompareTypeID>	parser_inspect_func_map_t;
+		typedef LLTypeInfoLookup<parser_inspect_func_t>		parser_inspect_func_map_t;
 
 		Parser(parser_read_func_map_t& read_map, parser_write_func_map_t& write_map, parser_inspect_func_map_t& inspect_map)
 		:	mParseSilently(false),
@@ -301,7 +302,7 @@ namespace LLInitParam
 	class Param;
 
 	// various callbacks and constraints associated with an individual param
-	struct ParamDescriptor
+	struct LL_COMMON_API ParamDescriptor
 	{
 		struct UserData
 		{
@@ -341,7 +342,7 @@ namespace LLInitParam
 	typedef boost::shared_ptr<ParamDescriptor> ParamDescriptorPtr;
 
 	// each derived Block class keeps a static data structure maintaining offsets to various params
-	class BlockDescriptor
+	class LL_COMMON_API BlockDescriptor
 	{
 	public:
 		BlockDescriptor();
@@ -369,7 +370,7 @@ namespace LLInitParam
 		class BaseBlock*				mCurrentBlockPtr;		// pointer to block currently being constructed
 	};
 
-	class BaseBlock
+	class LL_COMMON_API BaseBlock
 	{
 	public:
 		//TODO: implement in terms of owned_ptr
@@ -566,7 +567,7 @@ namespace LLInitParam
 		static bool equals(const BaseBlock::Lazy<T>& a, const BaseBlock::Lazy<T>& b) { return !a.empty() || !b.empty(); }
 	};
 
-	class Param
+	class LL_COMMON_API Param
 	{
 	public:
 		void setProvided(bool is_provided = true)
@@ -1253,15 +1254,16 @@ namespace LLInitParam
 			return mValues.back();
 		}
 
-		void add(const value_t& item)
+		self_t& add(const value_t& item)
 		{
 			param_value_t param_value;
 			param_value.setValue(item);
 			mValues.push_back(param_value);
 			setProvided();
+			return *this;
 		}
 
-		void add(const typename name_value_lookup_t::name_t& name)
+		self_t& add(const typename name_value_lookup_t::name_t& name)
 		{
 			value_t value;
 
@@ -1271,6 +1273,8 @@ namespace LLInitParam
 				add(value);
 				mValues.back().setValueName(name);
 			}
+
+			return *this;
 		}
 
 		// implicit conversion
@@ -1441,13 +1445,14 @@ namespace LLInitParam
 			return mValues.back();
 		}
 
-		void add(const value_t& item)
+		self_t& add(const value_t& item)
 		{
 			mValues.push_back(item);
 			setProvided();
+			return *this;
 		}
 
-		void add(const typename name_value_lookup_t::name_t& name)
+		self_t& add(const typename name_value_lookup_t::name_t& name)
 		{
 			value_t value;
 
@@ -1457,6 +1462,7 @@ namespace LLInitParam
 				add(value);
 				mValues.back().setValueName(name);
 			}
+			return *this;
 		}
 
 		// implicit conversion
@@ -2057,8 +2063,8 @@ namespace LLInitParam
 		
 
 		// block param interface
-		bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name);
+		LL_COMMON_API bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name);
-		void serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const;
+		LL_COMMON_API void serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const;
 		bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const
 		{
 			//TODO: implement LLSD params as schema type Any

indra/llcommon/llsortedvector.h

@@ -0,0 +1,152 @@
+/**
+ * @file   llsortedvector.h
+ * @author Nat Goodspeed
+ * @date   2012-04-08
+ * @brief  LLSortedVector class wraps a vector that we maintain in sorted
+ *         order so we can perform binary-search lookups.
+ * 
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Copyright (c) 2012, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLSORTEDVECTOR_H)
+#define LL_LLSORTEDVECTOR_H
+
+#include <vector>
+#include <algorithm>
+
+/**
+ * LLSortedVector contains a std::vector<std::pair> that we keep sorted on the
+ * first of the pair. This makes insertion somewhat more expensive than simple
+ * std::vector::push_back(), but allows us to use binary search for lookups.
+ * It's intended for small aggregates where lookup is far more performance-
+ * critical than insertion; in such cases a binary search on a small, sorted
+ * std::vector can be more performant than a std::map lookup.
+ */
+template <typename KEY, typename VALUE>
+class LLSortedVector
+{
+public:
+    typedef LLSortedVector<KEY, VALUE> self;
+    typedef KEY key_type;
+    typedef VALUE mapped_type;
+    typedef std::pair<key_type, mapped_type> value_type;
+    typedef std::vector<value_type> PairVector;
+    typedef typename PairVector::iterator iterator;
+    typedef typename PairVector::const_iterator const_iterator;
+
+    /// Empty
+    LLSortedVector() {}
+
+    /// Fixed initial size
+    LLSortedVector(std::size_t size):
+        mVector(size)
+    {}
+
+    /// Bulk load
+    template <typename ITER>
+    LLSortedVector(ITER begin, ITER end):
+        mVector(begin, end)
+    {
+        // Allow caller to dump in a bunch of (pairs convertible to)
+        // value_type if desired, but make sure we sort afterwards.
+        std::sort(mVector.begin(), mVector.end());
+    }
+
+    /// insert(key, value)
+    std::pair<iterator, bool> insert(const key_type& key, const mapped_type& value)
+    {
+        return insert(value_type(key, value));
+    }
+
+    /// insert(value_type)
+    std::pair<iterator, bool> insert(const value_type& pair)
+    {
+        typedef std::pair<iterator, bool> iterbool;
+        iterator found = std::lower_bound(mVector.begin(), mVector.end(), pair,
+                                          less<value_type>());
+        // have to check for end() before it's even valid to dereference
+        if (found == mVector.end())
+        {
+            std::size_t index(mVector.size());
+            mVector.push_back(pair);
+            // don't forget that push_back() invalidates 'found'
+            return iterbool(mVector.begin() + index, true);
+        }
+        if (found->first == pair.first)
+        {
+            return iterbool(found, false);
+        }
+        // remember that insert() invalidates 'found' -- save index
+        std::size_t index(found - mVector.begin());
+        mVector.insert(found, pair);
+        // okay, convert from index back to iterator
+        return iterbool(mVector.begin() + index, true);
+    }
+
+    iterator begin() { return mVector.begin(); }
+    iterator end()   { return mVector.end(); }
+    const_iterator begin() const { return mVector.begin(); }
+    const_iterator end()   const { return mVector.end(); }
+
+    bool empty() const { return mVector.empty(); }
+    std::size_t size() const { return mVector.size(); }
+
+    /// find
+    iterator find(const key_type& key)
+    {
+        iterator found = std::lower_bound(mVector.begin(), mVector.end(),
+                                          value_type(key, mapped_type()),
+                                          less<value_type>());
+        if (found == mVector.end() || found->first != key)
+            return mVector.end();
+        return found;
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        return const_cast<self*>(this)->find(key);
+    }
+
+private:
+    // Define our own 'less' comparator so we can specialize without messing
+    // with std::less.
+    template <typename T>
+    struct less: public std::less<T> {};
+
+    // Specialize 'less' for an LLSortedVector::value_type involving
+    // std::type_info*. This is one of LLSortedVector's foremost use cases. We
+    // specialize 'less' rather than just defining a specific comparator
+    // because LLSortedVector should be usable for other key_types as well.
+    template <typename T>
+    struct less< std::pair<std::type_info*, T> >:
+        public std::binary_function<std::pair<std::type_info*, T>,
+                                    std::pair<std::type_info*, T>,
+                                    bool>
+    {
+        bool operator()(const std::pair<std::type_info*, T>& lhs,
+                        const std::pair<std::type_info*, T>& rhs) const
+        {
+            return lhs.first->before(*rhs.first);
+        }
+    };
+
+    // Same as above, but with const std::type_info*.
+    template <typename T>
+    struct less< std::pair<const std::type_info*, T> >:
+        public std::binary_function<std::pair<const std::type_info*, T>,
+                                    std::pair<const std::type_info*, T>,
+                                    bool>
+    {
+        bool operator()(const std::pair<const std::type_info*, T>& lhs,
+                        const std::pair<const std::type_info*, T>& rhs) const
+        {
+            return lhs.first->before(*rhs.first);
+        }
+    };
+
+    PairVector mVector;
+};
+
+#endif /* ! defined(LL_LLSORTEDVECTOR_H) */

indra/llcommon/llstrider.h

@@ -42,10 +42,10 @@ template <class Object> class LLStrider
 		U8*		mBytep;
 	};
 	U32     mSkip;
-	//U32		mTypeSize;
+
 public:
 
-	LLStrider()  { mObjectp = NULL; /*mTypeSize = */mSkip = sizeof(Object); } 
+	LLStrider()  { mObjectp = NULL; mSkip = sizeof(Object); } 
 	~LLStrider() { } 
 
 	const LLStrider<Object>& operator =  (Object *first)    { mObjectp = first; return *this;}
@@ -60,9 +60,6 @@ public:
 		return ret;
 	}
 	
-	//void setTypeSize (S32 typeBytes){ mTypeSize = (typeBytes ? typeBytes : sizeof(Object)); }
-
-	//bool isStrided() const		   { return mTypeSize != mSkip; } 
 	void skip(const U32 index)     { mBytep += mSkip*index;}
 	U32 getSkip() const			   { return mSkip; }
 	Object* get()                  { return mObjectp; }
@@ -70,72 +67,9 @@ public:
 	Object& operator *()           { return *mObjectp; }
 	Object* operator ++(int)       { Object* old = mObjectp; mBytep += mSkip; return old; }
 	Object* operator +=(int i)     { mBytep += mSkip*i; return mObjectp; }
+
 	Object& operator[](U32 index)  { return *(Object*)(mBytep + (mSkip * index)); }
-	/*void assignArray(U8* __restrict source, const size_t elem_size, const size_t elem_count)
-	{
-		llassert_always(sizeof(Object) <= elem_size);
 	
-		U8* __restrict dest = mBytep;				//refer to dest instead of mBytep to benefit from __restrict hint
-		const U32 bytes = elem_size * elem_count;	//total bytes to copy from source to dest
-
-		//stride == sizeof(element) implies entire buffer is unstrided and thus memcpy-able, provided source buffer elements match in size.
-		//Because LLStrider is often passed an LLVector3 even if the reprensentation is LLVector4 in the vertex buffer, mTypeSize is set to 
-		//the TRUE vbo datatype size via VertexBufferStrider::get
-		if(!isStrided() && mTypeSize == elem_size)	
-		{
-			if(bytes >= sizeof(LLVector4) * 4)	//Should be able to pull at least 3 16byte blocks from this. Smaller isn't really beneficial.
-			{
-				U8* __restrict aligned_source = LL_NEXT_ALIGNED_ADDRESS(source);
-				U8* __restrict aligned_dest = LL_NEXT_ALIGNED_ADDRESS(dest);
-				const U32 source_offset = aligned_source - source;	//Offset to first aligned location in source buffer.
-				const U32 dest_offset = aligned_dest - dest;		//Offset to first aligned location in dest buffer.
-				llassert_always(source_offset < 16);
-				llassert_always(dest_offset < 16);
-				if(source_offset == dest_offset)	//delta to aligned location matches between source and destination! _mm_*_ps should be viable.
-				{
-					const U32 end_offset = (bytes - source_offset) % sizeof(LLVector4);		//buffers may not neatly end on a 16byte alignment boundary.
-					const U32 aligned_bytes = bytes - source_offset - end_offset;	//how many bytes to copy from aligned start to aligned end.
-
-					llassert_always(aligned_bytes > 0);
-
-					if(source_offset)	//memcpy up to the aligned location if needed
-						memcpy(dest,source,source_offset);
-					LLVector4a::memcpyNonAliased16((F32*) aligned_dest, (F32*) aligned_source, aligned_bytes);
-					if(end_offset)		//memcpy to the very end if needed.
-						memcpy(aligned_dest+aligned_bytes,aligned_source+aligned_bytes,end_offset);
-				}
-				else	//buffers non-uniformly offset from aligned location. Using _mm_*u_ps.
-				{
-					U32 end = bytes/sizeof(LLVector4);	//sizeof(LLVector4) = 16 bytes = 128 bits
-
-					llassert_always(end > 0);
-
-					__m128* dst = (__m128*) dest;
-					__m128* src = (__m128*) source;			
-
-					for (U32 i = 0; i < end; i++)	//copy 128bit chunks
-					{
-						__m128 res = _mm_loadu_ps((F32*)&src[i]);
-						_mm_storeu_ps((F32*)&dst[i], res);
-					}
-					end*=16;//Convert to real byte offset
-					if(end < bytes)	//just memcopy the rest
-						memcpy(dest+end,source+end,bytes-end);
-				}
-			}
-			else	//Too small. just do a simple memcpy.
-				memcpy(dest,source,bytes);
-		}
-		else
-		{
-			for(U32 i=0;i<elem_count;i++)
-			{
-				memcpy(dest,source,sizeof(Object));
-				dest+=mSkip;
-				source+=elem_size;
-			}
-		}
-	}*/
 };
 
 #endif // LL_LLSTRIDER_H

indra/llcommon/llstring.cpp

@@ -34,7 +34,6 @@
 
 #include "llstring.h"
 #include "llerror.h"
-#include "llfasttimer.h"
 
 #if LL_WINDOWS
 #define WIN32_LEAN_AND_MEAN
@@ -604,16 +603,10 @@ std::string utf8str_removeCRLF(const std::string& utf8str)
 	}
 	const char CR = 13;
 
-	S32 i = utf8str.find(CR);
-	if(i == std::string::npos)
-		return  utf8str; //Save us from a reserve call.
-
 	std::string out;
 	out.reserve(utf8str.length());
 	const S32 len = (S32)utf8str.length();
-	if(i)
+	for( S32 i = 0; i < len; i++ )
-		out.assign(utf8str,0,i); //Copy previous text to buffer
-	for( ++i; i < len; i++ )
 	{
 		if( utf8str[i] != CR )
 		{

indra/llcommon/llstring.h

@@ -35,11 +35,10 @@
 
 #include <string>
 #include <cstdio>
-#include <algorithm>
-#include <map>
 #include <locale>
 #include <iomanip>
 #include "llsd.h"
+#include "llfasttimer.h"
 
 #if LL_LINUX || LL_SOLARIS
 #include <wctype.h>
@@ -47,6 +46,7 @@
 #endif
 
 #include <string.h>
+#include <boost/scoped_ptr.hpp>
 
 #if LL_SOLARIS
 // stricmp and strnicmp do not exist on Solaris:
@@ -246,40 +246,77 @@ private:
 	static std::string sLocale;
 
 public:
-	typedef typename std::basic_string<T>::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 std::basic_string<T> null;
+	static const string_type null;
 	
 	typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
-	LL_COMMON_API static void getTokens(const std::basic_string<T>& instr, std::vector<std::basic_string<T> >& tokens, const std::basic_string<T>& delims);
+	/// considers any sequence of delims as a single field separator
-	LL_COMMON_API static void formatNumber(std::basic_string<T>& numStr, std::basic_string<T> decimals);
+	LL_COMMON_API static void getTokens(const string_type& instr,
-	LL_COMMON_API static bool formatDatetime(std::basic_string<T>& replacement, std::basic_string<T> token, std::basic_string<T> param, S32 secFromEpoch);
+										std::vector<string_type >& tokens,
-	LL_COMMON_API static S32 format(std::basic_string<T>& s, const format_map_t& substitutions);
+										const string_type& delims);
-	LL_COMMON_API static S32 format(std::basic_string<T>& s, const LLSD& substitutions);
+	/// like simple scan overload, but returns scanned vector
-	LL_COMMON_API static bool simpleReplacement(std::basic_string<T>& replacement, std::basic_string<T> token, const format_map_t& substitutions);
+	static std::vector<string_type> getTokens(const string_type& instr,
-	LL_COMMON_API static bool simpleReplacement(std::basic_string<T>& replacement, std::basic_string<T> token, const LLSD& substitutions);
+											  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 std::basic_string<T>& string, size_type i)
+	static bool isValidIndex(const string_type& string, size_type i)
 	{
 		return !string.empty() && (0 <= i) && (i <= string.size());
 	}
 
-	static void	trimHead(std::basic_string<T>& string);
+	static bool contains(const string_type& string, T c, size_type i=0)
-	static void	trimTail(std::basic_string<T>& string);
+	{
-	static void	trim(std::basic_string<T>& string)	{ trimHead(string); trimTail(string); }
+		return string.find(c, i) != string_type::npos;
-	static void truncate(std::basic_string<T>& string, size_type count);
+	}
 
-	static void	toUpper(std::basic_string<T>& string);
+	static void	trimHead(string_type& string);
-	static void	toLower(std::basic_string<T>& 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 std::basic_string<T>& string, const T* s ); 
+	static BOOL	isHead( const string_type& string, const T* s ); 
 
 	/**
 	 * @brief Returns true if string starts with substr
@@ -287,8 +324,8 @@ public:
 	 * If etither string or substr are empty, this method returns false.
 	 */
 	static bool startsWith(
-		const std::basic_string<T>& string,
+		const string_type& string,
-		const std::basic_string<T>& substr);
+		const string_type& substr);
 
 	/**
 	 * @brief Returns true if string ends in substr
@@ -296,19 +333,32 @@ public:
 	 * If etither string or substr are empty, this method returns false.
 	 */
 	static bool endsWith(
-		const std::basic_string<T>& string,
+		const string_type& string,
-		const std::basic_string<T>& substr);
+		const string_type& substr);
 
-	static void	addCRLF(std::basic_string<T>& string);
+	static void	addCRLF(string_type& string);
-	static void	removeCRLF(std::basic_string<T>& string);
+	static void	removeCRLF(string_type& string);
 
-	static void	replaceTabsWithSpaces( std::basic_string<T>& string, size_type spaces_per_tab );
+	static void	replaceTabsWithSpaces( string_type& string, size_type spaces_per_tab );
-	static void	replaceNonstandardASCII( std::basic_string<T>& string, T replacement );
+	static void	replaceNonstandardASCII( string_type& string, T replacement );
-	static void	replaceChar( std::basic_string<T>& string, T target, T replacement );
+	static void	replaceChar( string_type& string, T target, T replacement );
-	static void replaceString( std::basic_string<T>& string, std::basic_string<T> target, std::basic_string<T> replacement );
+	static void replaceString( string_type& string, string_type target, string_type replacement );
 	
-	static BOOL	containsNonprintable(const std::basic_string<T>& string);
+	static BOOL	containsNonprintable(const string_type& string);
-	static void	stripNonprintable(std::basic_string<T>& 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
@@ -317,18 +367,18 @@ public:
 	 * The 2 and 4 byte std::string probably work, so LLWStringUtil::_makeASCII
 	 * should work.
 	 */
-	static void _makeASCII(std::basic_string<T>& string);
+	static void _makeASCII(string_type& string);
 
 	// Conversion to other data types
-	static BOOL	convertToBOOL(const std::basic_string<T>& string, BOOL& value);
+	static BOOL	convertToBOOL(const string_type& string, BOOL& value);
-	static BOOL	convertToU8(const std::basic_string<T>& string, U8& value);
+	static BOOL	convertToU8(const string_type& string, U8& value);
-	static BOOL	convertToS8(const std::basic_string<T>& string, S8& value);
+	static BOOL	convertToS8(const string_type& string, S8& value);
-	static BOOL	convertToS16(const std::basic_string<T>& string, S16& value);
+	static BOOL	convertToS16(const string_type& string, S16& value);
-	static BOOL	convertToU16(const std::basic_string<T>& string, U16& value);
+	static BOOL	convertToU16(const string_type& string, U16& value);
-	static BOOL	convertToU32(const std::basic_string<T>& string, U32& value);
+	static BOOL	convertToU32(const string_type& string, U32& value);
-	static BOOL	convertToS32(const std::basic_string<T>& string, S32& value);
+	static BOOL	convertToS32(const string_type& string, S32& value);
-	static BOOL	convertToF32(const std::basic_string<T>& string, F32& value);
+	static BOOL	convertToF32(const string_type& string, F32& value);
-	static BOOL	convertToF64(const std::basic_string<T>& string, F64& value);
+	static BOOL	convertToF64(const string_type& string, F64& value);
 
 	/////////////////////////////////////////////////////////////////////////////////////////
 	// Utility functions for working with char*'s and strings
@@ -336,24 +386,24 @@ public:
 	// Like strcmp but also handles empty strings. Uses
 	// current locale.
 	static S32		compareStrings(const T* lhs, const T* rhs);
-	static S32		compareStrings(const std::basic_string<T>& lhs, const std::basic_string<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 std::basic_string<T>& lhs, const std::basic_string<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 std::basic_string<T>& a, const std::basic_string<T>& b);
+	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 std::basic_string<T>& a, const std::basic_string<T>& b);
+	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 std::basic_string<T>& a, const std::basic_string<T>& b );
+	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
@@ -361,7 +411,7 @@ public:
 	static void		copy(T* dst, const T* src, size_type dst_size);
 	
 	// Copies src into dst at a given offset.  
-	static void		copyInto(std::basic_string<T>& dst, const std::basic_string<T>& src, size_type 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); }
 
@@ -371,7 +421,7 @@ public:
 #endif
 
 private:
-	LL_COMMON_API static size_type getSubstitution(const std::basic_string<T>& instr, size_type& start, std::vector<std::basic_string<T> >& 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;
@@ -649,6 +699,321 @@ namespace LLStringFn
 
 ////////////////////////////////////////////////////////////
 
+// static
+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;
+}
+
+// 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)
+{
+	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;
+}
+
+namespace LLStringUtilBaseImpl
+{
+
+/**
+ * Input string scanner helper for getTokens(), or really any other
+ * character-parsing routine that may have to deal with escape characters.
+ * This implementation defines the concept (also an interface, should you
+ * choose to implement the concept by subclassing) and provides trivial
+ * implementations for a string @em without escape processing.
+ */
+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;
+};
+
+/// InString subclass that handles escape characters
+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;
+	}
+
+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;
+};
+
+/// 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;
+		}
+	}
+}
+
+} // namespace LLStringUtilBaseImpl
+
+// 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)
+{
+	// 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).
+	boost::scoped_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> 
@@ -678,7 +1043,7 @@ S32 LLStringUtilBase<T>::compareStrings(const T* lhs, const T* rhs)
 
 //static 
 template<class T> 
-S32 LLStringUtilBase<T>::compareStrings(const std::basic_string<T>& lhs, const std::basic_string<T>& rhs)
+S32 LLStringUtilBase<T>::compareStrings(const string_type& lhs, const string_type& rhs)
 {
 	return LLStringOps::collate(lhs.c_str(), rhs.c_str());
 }
@@ -704,8 +1069,8 @@ S32 LLStringUtilBase<T>::compareInsensitive(const T* lhs, const T* rhs )
 	}
 	else
 	{
-		std::basic_string<T> lhs_string(lhs);
+		string_type lhs_string(lhs);
-		std::basic_string<T> rhs_string(rhs);
+		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());
@@ -715,10 +1080,10 @@ S32 LLStringUtilBase<T>::compareInsensitive(const T* lhs, const T* rhs )
 
 //static 
 template<class T> 
-S32 LLStringUtilBase<T>::compareInsensitive(const std::basic_string<T>& lhs, const std::basic_string<T>& rhs)
+S32 LLStringUtilBase<T>::compareInsensitive(const string_type& lhs, const string_type& rhs)
 {
-	std::basic_string<T> lhs_string(lhs);
+	string_type lhs_string(lhs);
-	std::basic_string<T> rhs_string(rhs);
+	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());
@@ -729,7 +1094,7 @@ S32 LLStringUtilBase<T>::compareInsensitive(const std::basic_string<T>& lhs, con
 
 //static 
 template<class T>
-S32 LLStringUtilBase<T>::compareDict(const std::basic_string<T>& astr, const std::basic_string<T>& bstr)
+S32 LLStringUtilBase<T>::compareDict(const string_type& astr, const string_type& bstr)
 {
 	const T* a = astr.c_str();
 	const T* b = bstr.c_str();
@@ -770,7 +1135,7 @@ S32 LLStringUtilBase<T>::compareDict(const std::basic_string<T>& astr, const std
 
 // static
 template<class T>
-S32 LLStringUtilBase<T>::compareDictInsensitive(const std::basic_string<T>& astr, const std::basic_string<T>& bstr)
+S32 LLStringUtilBase<T>::compareDictInsensitive(const string_type& astr, const string_type& bstr)
 {
 	const T* a = astr.c_str();
 	const T* b = bstr.c_str();
@@ -805,7 +1170,7 @@ S32 LLStringUtilBase<T>::compareDictInsensitive(const std::basic_string<T>& astr
 // Puts compareDict() in a form appropriate for LL container classes to use for sorting.
 // static 
 template<class T> 
-BOOL LLStringUtilBase<T>::precedesDict( const std::basic_string<T>& a, const std::basic_string<T>& b )
+BOOL LLStringUtilBase<T>::precedesDict( const string_type& a, const string_type& b )
 {
 	if( a.size() && b.size() )
 	{
@@ -819,7 +1184,7 @@ BOOL LLStringUtilBase<T>::precedesDict( const std::basic_string<T>& a, const std
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::toUpper(std::basic_string<T>& string)	
+void LLStringUtilBase<T>::toUpper(string_type& string)	
 { 
 	if( !string.empty() )
 	{ 
@@ -833,7 +1198,7 @@ void LLStringUtilBase<T>::toUpper(std::basic_string<T>& string)
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::toLower(std::basic_string<T>& string)
+void LLStringUtilBase<T>::toLower(string_type& string)
 { 
 	if( !string.empty() )
 	{ 
@@ -847,7 +1212,7 @@ void LLStringUtilBase<T>::toLower(std::basic_string<T>& string)
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::trimHead(std::basic_string<T>& string)
+void LLStringUtilBase<T>::trimHead(string_type& string)
 {			
 	if( !string.empty() )
 	{
@@ -862,7 +1227,7 @@ void LLStringUtilBase<T>::trimHead(std::basic_string<T>& string)
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::trimTail(std::basic_string<T>& string)
+void LLStringUtilBase<T>::trimTail(string_type& string)
 {			
 	if( string.size() )
 	{
@@ -881,7 +1246,7 @@ void LLStringUtilBase<T>::trimTail(std::basic_string<T>& string)
 // Replace line feeds with carriage return-line feed pairs.
 //static
 template<class T>
-void LLStringUtilBase<T>::addCRLF(std::basic_string<T>& string)
+void LLStringUtilBase<T>::addCRLF(string_type& string)
 {
 	const T LF = 10;
 	const T CR = 13;
@@ -923,7 +1288,7 @@ void LLStringUtilBase<T>::addCRLF(std::basic_string<T>& string)
 // Remove all carriage returns
 //static
 template<class T> 
-void LLStringUtilBase<T>::removeCRLF(std::basic_string<T>& string)
+void LLStringUtilBase<T>::removeCRLF(string_type& string)
 {
 	const T CR = 13;
 
@@ -944,10 +1309,10 @@ void LLStringUtilBase<T>::removeCRLF(std::basic_string<T>& string)
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::replaceChar( std::basic_string<T>& string, T target, T replacement )
+void LLStringUtilBase<T>::replaceChar( string_type& string, T target, T replacement )
 {
 	size_type found_pos = 0;
-	while( (found_pos = string.find(target, found_pos)) != std::basic_string<T>::npos ) 
+	while( (found_pos = string.find(target, found_pos)) != string_type::npos ) 
 	{
 		string[found_pos] = replacement;
 		found_pos++; // avoid infinite defeat if target == replacement
@@ -956,10 +1321,10 @@ void LLStringUtilBase<T>::replaceChar( std::basic_string<T>& string, T target, T
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::replaceString( std::basic_string<T>& string, std::basic_string<T> target, std::basic_string<T> replacement )
+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)) != std::basic_string<T>::npos )
+	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
@@ -968,7 +1333,7 @@ void LLStringUtilBase<T>::replaceString( std::basic_string<T>& string, std::basi
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::replaceNonstandardASCII( std::basic_string<T>& string, T replacement )
+void LLStringUtilBase<T>::replaceNonstandardASCII( string_type& string, T replacement )
 {
 	const char LF = 10;
 	const S8 MIN = 32;
@@ -988,12 +1353,12 @@ void LLStringUtilBase<T>::replaceNonstandardASCII( std::basic_string<T>& string,
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::replaceTabsWithSpaces( std::basic_string<T>& str, size_type spaces_per_tab )
+void LLStringUtilBase<T>::replaceTabsWithSpaces( string_type& str, size_type spaces_per_tab )
 {
 	const T TAB = '\t';
 	const T SPACE = ' ';
 
-	std::basic_string<T> out_str;
+	string_type out_str;
 	// Replace tabs with spaces
 	for (size_type i = 0; i < str.length(); i++)
 	{
@@ -1012,7 +1377,7 @@ void LLStringUtilBase<T>::replaceTabsWithSpaces( std::basic_string<T>& str, size
 
 //static
 template<class T> 
-BOOL LLStringUtilBase<T>::containsNonprintable(const std::basic_string<T>& string)
+BOOL LLStringUtilBase<T>::containsNonprintable(const string_type& string)
 {
 	const char MIN = 32;
 	BOOL rv = FALSE;
@@ -1029,7 +1394,7 @@ BOOL LLStringUtilBase<T>::containsNonprintable(const std::basic_string<T>& strin
 
 //static
 template<class T> 
-void LLStringUtilBase<T>::stripNonprintable(std::basic_string<T>& string)
+void LLStringUtilBase<T>::stripNonprintable(string_type& string)
 {
 	const char MIN = 32;
 	size_type j = 0;
@@ -1061,7 +1426,42 @@ void LLStringUtilBase<T>::stripNonprintable(std::basic_string<T>& string)
 }
 
 template<class T>
-void LLStringUtilBase<T>::_makeASCII(std::basic_string<T>& string)
+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;
+}
+
+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++)
@@ -1091,7 +1491,7 @@ void LLStringUtilBase<T>::copy( T* dst, const T* src, size_type dst_size )
 
 // static
 template<class T> 
-void LLStringUtilBase<T>::copyInto(std::basic_string<T>& dst, const std::basic_string<T>& src, size_type offset)
+void LLStringUtilBase<T>::copyInto(string_type& dst, const string_type& src, size_type offset)
 {
 	if ( offset == dst.length() )
 	{
@@ -1101,7 +1501,7 @@ void LLStringUtilBase<T>::copyInto(std::basic_string<T>& dst, const std::basic_s
 	}
 	else
 	{
-		std::basic_string<T> tail = dst.substr(offset);
+		string_type tail = dst.substr(offset);
 
 		dst = dst.substr(0, offset);
 		dst += src;
@@ -1112,7 +1512,7 @@ void LLStringUtilBase<T>::copyInto(std::basic_string<T>& dst, const std::basic_s
 // True if this is the head of s.
 //static
 template<class T> 
-BOOL LLStringUtilBase<T>::isHead( const std::basic_string<T>& string, const T* s ) 
+BOOL LLStringUtilBase<T>::isHead( const string_type& string, const T* s ) 
 { 
 	if( string.empty() )
 	{
@@ -1128,8 +1528,8 @@ BOOL LLStringUtilBase<T>::isHead( const std::basic_string<T>& string, const T* s
 // static
 template<class T> 
 bool LLStringUtilBase<T>::startsWith(
-	const std::basic_string<T>& string,
+	const string_type& string,
-	const std::basic_string<T>& substr)
+	const string_type& substr)
 {
 	if(string.empty() || (substr.empty())) return false;
 	if(0 == string.find(substr)) return true;
@@ -1139,8 +1539,8 @@ bool LLStringUtilBase<T>::startsWith(
 // static
 template<class T> 
 bool LLStringUtilBase<T>::endsWith(
-	const std::basic_string<T>& string,
+	const string_type& string,
-	const std::basic_string<T>& substr)
+	const string_type& substr)
 {
 	if(string.empty() || (substr.empty())) return false;
 	std::string::size_type idx = string.rfind(substr);
@@ -1150,14 +1550,14 @@ bool LLStringUtilBase<T>::endsWith(
 
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToBOOL(const std::basic_string<T>& string, BOOL& value)
+BOOL LLStringUtilBase<T>::convertToBOOL(const string_type& string, BOOL& value)
 {
 	if( string.empty() )
 	{
 		return FALSE;
 	}
 
-	std::basic_string<T> temp( string );
+	string_type temp( string );
 	trim(temp);
 	if( 
 		(temp == "1") || 
@@ -1187,7 +1587,7 @@ BOOL LLStringUtilBase<T>::convertToBOOL(const std::basic_string<T>& string, BOOL
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToU8(const std::basic_string<T>& string, U8& value) 
+BOOL LLStringUtilBase<T>::convertToU8(const string_type& string, U8& value) 
 {
 	S32 value32 = 0;
 	BOOL success = convertToS32(string, value32);
@@ -1200,7 +1600,7 @@ BOOL LLStringUtilBase<T>::convertToU8(const std::basic_string<T>& string, U8& va
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToS8(const std::basic_string<T>& string, S8& value) 
+BOOL LLStringUtilBase<T>::convertToS8(const string_type& string, S8& value) 
 {
 	S32 value32 = 0;
 	BOOL success = convertToS32(string, value32);
@@ -1213,7 +1613,7 @@ BOOL LLStringUtilBase<T>::convertToS8(const std::basic_string<T>& string, S8& va
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToS16(const std::basic_string<T>& string, S16& value) 
+BOOL LLStringUtilBase<T>::convertToS16(const string_type& string, S16& value) 
 {
 	S32 value32 = 0;
 	BOOL success = convertToS32(string, value32);
@@ -1226,7 +1626,7 @@ BOOL LLStringUtilBase<T>::convertToS16(const std::basic_string<T>& string, S16&
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToU16(const std::basic_string<T>& string, U16& value) 
+BOOL LLStringUtilBase<T>::convertToU16(const string_type& string, U16& value) 
 {
 	S32 value32 = 0;
 	BOOL success = convertToS32(string, value32);
@@ -1239,17 +1639,17 @@ BOOL LLStringUtilBase<T>::convertToU16(const std::basic_string<T>& string, U16&
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToU32(const std::basic_string<T>& string, U32& value) 
+BOOL LLStringUtilBase<T>::convertToU32(const string_type& string, U32& value) 
 {
 	if( string.empty() )
 	{
 		return FALSE;
 	}
 
-	std::basic_string<T> temp( string );
+	string_type temp( string );
 	trim(temp);
 	U32 v;
-	std::basic_istringstream<T> i_stream((std::basic_string<T>)temp);
+	std::basic_istringstream<T> i_stream((string_type)temp);
 	if(i_stream >> v)
 	{
 		value = v;
@@ -1259,17 +1659,17 @@ BOOL LLStringUtilBase<T>::convertToU32(const std::basic_string<T>& string, U32&
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToS32(const std::basic_string<T>& string, S32& value) 
+BOOL LLStringUtilBase<T>::convertToS32(const string_type& string, S32& value) 
 {
 	if( string.empty() )
 	{
 		return FALSE;
 	}
 
-	std::basic_string<T> temp( string );
+	string_type temp( string );
 	trim(temp);
 	S32 v;
-	std::basic_istringstream<T> i_stream((std::basic_string<T>)temp);
+	std::basic_istringstream<T> i_stream((string_type)temp);
 	if(i_stream >> v)
 	{
 		//TODO: figure out overflow and underflow reporting here
@@ -1286,7 +1686,7 @@ BOOL LLStringUtilBase<T>::convertToS32(const std::basic_string<T>& string, S32&
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToF32(const std::basic_string<T>& string, F32& value) 
+BOOL LLStringUtilBase<T>::convertToF32(const string_type& string, F32& value) 
 {
 	F64 value64 = 0.0;
 	BOOL success = convertToF64(string, value64);
@@ -1299,17 +1699,17 @@ BOOL LLStringUtilBase<T>::convertToF32(const std::basic_string<T>& string, F32&
 }
 
 template<class T> 
-BOOL LLStringUtilBase<T>::convertToF64(const std::basic_string<T>& string, F64& value)
+BOOL LLStringUtilBase<T>::convertToF64(const string_type& string, F64& value)
 {
 	if( string.empty() )
 	{
 		return FALSE;
 	}
 
-	std::basic_string<T> temp( string );
+	string_type temp( string );
 	trim(temp);
 	F64 v;
-	std::basic_istringstream<T> i_stream((std::basic_string<T>)temp);
+	std::basic_istringstream<T> i_stream((string_type)temp);
 	if(i_stream >> v)
 	{
 		//TODO: figure out overflow and underflow reporting here
@@ -1326,7 +1726,7 @@ BOOL LLStringUtilBase<T>::convertToF64(const std::basic_string<T>& string, F64&
 }
 
 template<class T> 
-void LLStringUtilBase<T>::truncate(std::basic_string<T>& string, size_type count)
+void LLStringUtilBase<T>::truncate(string_type& string, size_type count)
 {
 	size_type cur_size = string.size();
 	string.resize(count < cur_size ? count : cur_size);

indra/llcommon/lltypeinfolookup.h

@@ -0,0 +1,110 @@
+/**
+ * @file   lltypeinfolookup.h
+ * @author Nat Goodspeed
+ * @date   2012-04-08
+ * @brief  Template data structure like std::map<std::type_info*, T>
+ * 
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Copyright (c) 2012, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLTYPEINFOLOOKUP_H)
+#define LL_LLTYPEINFOLOOKUP_H
+
+#include "llsortedvector.h"
+#include <typeinfo>
+
+/**
+ * LLTypeInfoLookup is specifically designed for use cases for which you might
+ * consider std::map<std::type_info*, VALUE>. We have several such data
+ * structures in the viewer. The trouble with them is that at least on Linux,
+ * you can't rely on always getting the same std::type_info* for a given type:
+ * different load modules will produce different std::type_info*.
+ * LLTypeInfoLookup contains a workaround to address this issue.
+ *
+ * Specifically, when we don't find the passed std::type_info*,
+ * LLTypeInfoLookup performs a linear search over registered entries to
+ * compare name() strings. Presuming that this succeeds, we cache the new
+ * (previously unrecognized) std::type_info* to speed future lookups.
+ *
+ * This worst-case fallback search (linear search with string comparison)
+ * should only happen the first time we look up a given type from a particular
+ * load module other than the one from which we initially registered types.
+ * (However, a lookup which wouldn't succeed anyway will always have
+ * worst-case performance.) This class is probably best used with less than a
+ * few dozen different types.
+ */
+template <typename VALUE>
+class LLTypeInfoLookup
+{
+public:
+    typedef LLTypeInfoLookup<VALUE> self;
+    typedef LLSortedVector<const std::type_info*, VALUE> vector_type;
+    typedef typename vector_type::key_type key_type;
+    typedef typename vector_type::mapped_type mapped_type;
+    typedef typename vector_type::value_type value_type;
+    typedef typename vector_type::iterator iterator;
+    typedef typename vector_type::const_iterator const_iterator;
+
+    LLTypeInfoLookup() {}
+
+    iterator begin() { return mVector.begin(); }
+    iterator end()   { return mVector.end(); }
+    const_iterator begin() const { return mVector.begin(); }
+    const_iterator end()   const { return mVector.end(); }
+    bool empty() const { return mVector.empty(); }
+    std::size_t size() const { return mVector.size(); }
+
+    std::pair<iterator, bool> insert(const std::type_info* key, const VALUE& value)
+    {
+        return insert(value_type(key, value));
+    }
+
+    std::pair<iterator, bool> insert(const value_type& pair)
+    {
+        return mVector.insert(pair);
+    }
+
+    // const find() forwards to non-const find(): this can alter mVector!
+    const_iterator find(const std::type_info* key) const
+    {
+        return const_cast<self*>(this)->find(key);
+    }
+
+    // non-const find() caches previously-unknown type_info* to speed future
+    // lookups.
+    iterator find(const std::type_info* key)
+    {
+        iterator found = mVector.find(key);
+        if (found != mVector.end())
+        {
+            // If LLSortedVector::find() found, great, we're done.
+            return found;
+        }
+        // Here we didn't find the passed type_info*. On Linux, though, even
+        // for the same type, typeid(sametype) produces a different type_info*
+        // when used in different load modules. So the fact that we didn't
+        // find the type_info* we seek doesn't mean this type isn't
+        // registered. Scan for matching name() string.
+        for (typename vector_type::iterator ti(mVector.begin()), tend(mVector.end());
+             ti != tend; ++ti)
+        {
+            if (std::string(ti->first->name()) == key->name())
+            {
+                // This unrecognized 'key' is for the same type as ti->first.
+                // To speed future lookups, insert a new entry that lets us
+                // look up ti->second using this same 'key'.
+                return insert(key, ti->second).first;
+            }
+        }
+        // We simply have never seen a type with this type_info* from any load
+        // module.
+        return mVector.end();
+    }
+
+private:
+    vector_type mVector;
+};
+
+#endif /* ! defined(LL_LLTYPEINFOLOOKUP_H) */

indra/llcommon/lluuid.h

@@ -34,7 +34,6 @@
 
 #include <iostream>
 #include <set>
-#include <vector>
 #include "stdtypes.h"
 #include "llpreprocessor.h"
 

indra/llimage/llimage.h

@@ -35,8 +35,8 @@
 
 #include "lluuid.h"
 #include "llstring.h"
-#include "llmemtype.h"
 #include "llthread.h"
+#include "llmemtype.h"
 #include "aithreadsafe.h"
 
 const S32 MIN_IMAGE_MIP =  2; // 4x4, only used for expand/contract power of 2

indra/llimage/llpngwrapper.h

@@ -32,7 +32,7 @@
 #ifndef LL_LLPNGWRAPPER_H
 #define LL_LLPNGWRAPPER_H
 
-#include "png.h"
+#include "libpng15/png.h"
 #include "llimage.h"
 
 class LLPngWrapper

indra/llinventory/llparcel.h

@@ -51,7 +51,7 @@ const S32 PARCEL_UNIT_AREA			= 16;
 const F32 PARCEL_HEIGHT = 50.f;
 
 //Height above ground which parcel boundries exist for explicitly banned avatars
-const F32 BAN_HEIGHT = 768.f;
+const F32 BAN_HEIGHT = 5000.f;
 
 // Maximum number of entries in an access list
 const S32 PARCEL_MAX_ACCESS_LIST = 300;
@@ -260,7 +260,7 @@ public:
 	void setMediaURLResetTimer(F32 time);
 	virtual void	setLocalID(S32 local_id);
 
-	// blow away all the extra crap lurking in parcels, including urls, access lists, etc
+	// blow away all the extra stuff lurking in parcels, including urls, access lists, etc
 	void clearParcel();
 
 	// This value is not persisted out to the parcel file, it is only
@@ -686,6 +686,7 @@ public:
 	std::map<LLUUID,LLAccessEntry>	mBanList;
 	std::map<LLUUID,LLAccessEntry>	mTempBanList;
 	std::map<LLUUID,LLAccessEntry>	mTempAccessList;
+
 };
 
 

indra/llinventory/llpermissionsflags.h

@@ -32,9 +32,6 @@
 #ifndef LL_LLPERMISSIONSFLAGS_H
 #define LL_LLPERMISSIONSFLAGS_H
 
-// llpermissionsflags.h
-// Copyright 2002, Linden Research, Inc.
-//
 // Flags for various permissions bits.
 // Shared between viewer and simulator.
 

indra/llinventory/lltransactiontypes.h

@@ -74,6 +74,7 @@ const S32 TRANS_CLASSIFIED_RENEW	= 2005;
 // automatically end up in the list below :-(
 // So make sure you check the transaction_description table
 const S32 TRANS_RECURRING_GENERIC  = 2100;
+
 // Codes 3000-3999 reserved for inventory transactions
 const S32 TRANS_GIVE_INVENTORY		= 3000;
 

indra/llmessage/llares.cpp

@@ -39,7 +39,6 @@
 
 #include "llapr.h"
 #include "llareslistener.h"
-#include "llscopedvolatileaprpool.h"
 
 #if defined(LL_WINDOWS)
 #pragma warning (disable : 4355) // 'this' used in initializer list: yes, intentionally
@@ -469,6 +468,7 @@ bool LLAres::process(U64 timeout)
 	ares_socket_t socks[ARES_GETSOCK_MAXNUM];
 	apr_pollfd_t aprFds[ARES_GETSOCK_MAXNUM];
 	apr_int32_t nsds = 0;	
+	apr_status_t status;
 	int nactive = 0;
 	int bitmask;
 
@@ -479,8 +479,6 @@ bool LLAres::process(U64 timeout)
 		return nsds > 0;
 	}
 
-	LLScopedVolatileAPRPool scoped_pool;
-
 	for (int i = 0; i < ARES_GETSOCK_MAXNUM; i++)
 	{
 		if (ARES_GETSOCK_READABLE(bitmask, i))
@@ -496,7 +494,7 @@ bool LLAres::process(U64 timeout)
 
 		apr_socket_t *aprSock = NULL;
 
-		apr_status_t status = apr_os_sock_put(&aprSock, (apr_os_sock_t *) &socks[i], scoped_pool);
+		status = apr_os_sock_put(&aprSock, (apr_os_sock_t *) &socks[i], LLAPRRootPool::get()());
 		if (status != APR_SUCCESS)
 		{
 			ll_apr_warn_status(status);
@@ -505,7 +503,7 @@ bool LLAres::process(U64 timeout)
 
 		aprFds[nactive].desc.s = aprSock;
 		aprFds[nactive].desc_type = APR_POLL_SOCKET;
-		aprFds[nactive].p = scoped_pool;
+		aprFds[nactive].p = LLAPRRootPool::get()();
 		aprFds[nactive].rtnevents = 0;
 		aprFds[nactive].client_data = &socks[i];
 
@@ -514,7 +512,7 @@ bool LLAres::process(U64 timeout)
 
 	if (nactive > 0)
 	{
-		apr_status_t status = apr_poll(aprFds, nactive, &nsds, timeout);
+		status = apr_poll(aprFds, nactive, &nsds, timeout);
 
 		if (status != APR_SUCCESS && status != APR_TIMEUP)
 		{

indra/llmessage/llbuffer.cpp

@@ -28,7 +28,6 @@
 
 #include "linden_common.h"
 #include "llbuffer.h"
-#include <iterator>
 
 #include "llmath.h"
 #include "llmemtype.h"

indra/llmessage/llcurl.h

@@ -42,11 +42,8 @@
 #include "lliopipe.h"
 #include "llsd.h"
 #include "llthread.h"
-#include "llqueuedthread.h"
-#include "llframetimer.h"
 
 class LLMutex;
-class LLCurlThread;
 
 // For whatever reason, this is not typedef'd in curl.h
 typedef size_t (*curl_header_callback)(void *ptr, size_t size, size_t nmemb, void *stream);
@@ -59,6 +56,8 @@ public:
 	class Easy;
 	class Multi;
 
+	static bool sMultiThreaded;
+
 	struct TransferInfo
 	{
 		TransferInfo() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {}
@@ -125,7 +124,6 @@ public:
 			{
 				return false;
 			}
-
 	public: /* but not really -- don't touch this */
 		U32 mReferenceCount;
 
@@ -163,7 +161,7 @@ public:
 	/**
 	 * @ brief Initialize LLCurl class
 	 */
-	static void initClass(F32 curl_reuest_timeout = 120.f, S32 max_number_handles = 256, bool multi_threaded = false);
+	static void initClass(bool multi_threaded = false);
 
 	/**
 	 * @ brief Cleanup LLCurl class
@@ -182,25 +180,10 @@ public:
 	static void ssl_locking_callback(int mode, int type, const char *file, int line);
 	static unsigned long ssl_thread_id(void);
 
-	static LLCurlThread* getCurlThread() { return sCurlThread ;}
-
-	static CURLM* newMultiHandle() ;
-	static CURLMcode deleteMultiHandle(CURLM* handle) ;
-	static CURL*  newEasyHandle() ;
-	static void   deleteEasyHandle(CURL* handle) ;
-
 private:
 	static std::string sCAPath;
 	static std::string sCAFile;
 	static const unsigned int MAX_REDIRECTS;
-	static LLCurlThread* sCurlThread;
-
-	static LLMutex* sHandleMutexp ;
-	static S32      sTotalHandles ;
-	static S32      sMaxHandles;
-public:
-	static bool     sNotQuitting;
-	static F32      sCurlRequestTimeOut;	
 };
 
 class LLCurl::Easy
@@ -223,7 +206,7 @@ public:
 	// These assume the setter does not free value!
 	void setopt(CURLoption option, void* value);
 	void setopt(CURLoption option, char* value);
-	// Copies the string so that it is guaranteed to stick around
+	// Copies the string so that it is gauranteed to stick around
 	void setoptString(CURLoption option, const std::string& value);
 	
 	void slist_append(const char* str);
@@ -232,7 +215,7 @@ public:
 	U32 report(CURLcode);
 	void getTransferInfo(LLCurl::TransferInfo* info);
 
-	void prepRequest(const std::string& url, const std::vector<std::string>& headers, LLCurl::ResponderPtr, S32 time_out = 0, bool post = false);
+	void prepRequest(const std::string& url, const std::vector<std::string>& headers, ResponderPtr, S32 time_out = 0, bool post = false);
 	
 	const char* getErrorBuffer();
 
@@ -263,126 +246,69 @@ private:
 	// Note: char*'s not strings since we pass pointers to curl
 	std::vector<char*>	mStrings;
 	
-	LLCurl::ResponderPtr		mResponder;
+	ResponderPtr		mResponder;
 
 	static std::set<CURL*> sFreeHandles;
 	static std::set<CURL*> sActiveHandles;
-	static LLMutex*        sHandleMutexp ;
+	static LLMutex* sHandleMutex;
+	static LLMutex* sMultiMutex;
 };
 
-class LLCurl::Multi
+class LLCurl::Multi : public LLThread
 {
 	LOG_CLASS(Multi);
-
-	friend class LLCurlThread ;
-
-private:
-	~Multi();
-
-	void markDead() ;
-	bool doPerform();
-
 public:
 
 	typedef enum
 	{
-		STATE_READY=0,
+		PERFORM_STATE_READY=0,
-		STATE_PERFORMING=1,
+		PERFORM_STATE_PERFORMING=1,
-		STATE_COMPLETED=2
+		PERFORM_STATE_COMPLETED=2
 	} ePerformState;
 
-	Multi(F32 idle_time_out = 0.f);	
+	Multi();
+	~Multi();
 
-	LLCurl::Easy* allocEasy();
+	Easy* allocEasy();
-	bool addEasy(LLCurl::Easy* easy);	
+	bool addEasy(Easy* easy);
-	void removeEasy(LLCurl::Easy* easy);
 	
-	void lock() ;
+	void removeEasy(Easy* easy);
-	void unlock() ;
-
-	void setState(ePerformState state) ;
-	ePerformState getState() ;
-	
-	bool isCompleted() ;
-	bool isValid() {return mCurlMultiHandle != NULL && mValid;}
-	bool isDead() {return mDead;}
-
-	bool waitToComplete() ;
 
 	S32 process();
+	void perform();
+	void doPerform();
+	
+	virtual void run();
 
 	CURLMsg* info_read(S32* msgs_in_queue);
 
 	S32 mQueued;
 	S32 mErrorCount;
 	
+	S32 mPerformState;
+
+	LLCondition* mSignal;
+	bool mQuitting;
+	bool mThreaded;
+
 private:
-	void easyFree(LLCurl::Easy*);
+	void easyFree(Easy*);
-	void cleanup(bool deleted = false);
 	
 	CURLM* mCurlMultiHandle;
 
-	typedef std::set<LLCurl::Easy*> easy_active_list_t;
+	typedef std::set<Easy*> easy_active_list_t;
 	easy_active_list_t mEasyActiveList;
-	typedef std::map<CURL*, LLCurl::Easy*> easy_active_map_t;
+	typedef std::map<CURL*, Easy*> easy_active_map_t;
 	easy_active_map_t mEasyActiveMap;
-	typedef std::set<LLCurl::Easy*> easy_free_list_t;
+	typedef std::set<Easy*> easy_free_list_t;
 	easy_free_list_t mEasyFreeList;
-
-	LLQueuedThread::handle_t mHandle ;
-	ePerformState mState;
-
-	BOOL mDead ;
-	BOOL mValid ;
-	LLMutex* mMutexp ;
-	LLMutex* mDeletionMutexp ;
-	LLMutex* mEasyMutexp ;
-	LLFrameTimer mIdleTimer ;
-	F32 mIdleTimeOut;
 };
 
-class LLCurlThread : public LLQueuedThread
+namespace boost
 {
-public:
-
-	class CurlRequest : public LLQueuedThread::QueuedRequest
-	{
-	protected:
-		virtual ~CurlRequest(); // use deleteRequest()
-		
-	public:
-		CurlRequest(handle_t handle, LLCurl::Multi* multi, LLCurlThread* curl_thread);
-
-		/*virtual*/ bool processRequest();
-		/*virtual*/ void finishRequest(bool completed);
-
-	private:
-		// input
-		LLCurl::Multi* mMulti;
-		LLCurlThread*  mCurlThread;
-	};
-	friend class CurlRequest;
-
-public:
-	LLCurlThread(bool threaded = true) ;
-	virtual ~LLCurlThread() ;
-
-	S32 update(F32 max_time_ms);
-
-	void addMulti(LLCurl::Multi* multi) ;
-	void killMulti(LLCurl::Multi* multi) ;
-
-private:
-	bool doMultiPerform(LLCurl::Multi* multi) ;
-	void deleteMulti(LLCurl::Multi* multi) ;
-	void cleanupMulti(LLCurl::Multi* multi) ;
-} ;
-
-//namespace boost
-//{
 	void intrusive_ptr_add_ref(LLCurl::Responder* p);
 	void intrusive_ptr_release(LLCurl::Responder* p);
-//};
+};
 
 
 class LLCurlRequest
@@ -412,6 +338,7 @@ private:
 	LLCurl::Multi* mActiveMulti;
 	S32 mActiveRequestCount;
 	BOOL mProcessing;
+	U32 mThreadID; // debug
 };
 
 class LLCurlEasyRequest
@@ -429,11 +356,9 @@ public:
 	void slist_append(const char* str);
 	void sendRequest(const std::string& url);
 	void requestComplete();
+	void perform();
 	bool getResult(CURLcode* result, LLCurl::TransferInfo* info = NULL);
 	std::string getErrorString();
-	bool isCompleted() {return mMulti->isCompleted() ;}
-	bool wait() { return mMulti->waitToComplete(); }
-	bool isValid() {return mMulti && mMulti->isValid(); }
 
 	LLCurl::Easy* getEasy() const { return mEasy; }
 

indra/llmessage/lldispatcher.cpp

@@ -29,7 +29,6 @@
 #include "lldispatcher.h"
 
 #include <algorithm>
-#include <iterator>
 #include "llstl.h"
 #include "message.h"
 

indra/llmessage/llfiltersd2xmlrpc.cpp

@@ -80,7 +80,6 @@
 
 #include "llbuffer.h"
 #include "llbufferstream.h"
-#include "llfasttimer.h"
 #include "llmemorystream.h"
 #include "llsd.h"
 #include "llsdserialize.h"

indra/llmessage/llhttpclient.cpp

@@ -25,7 +25,7 @@
  */
 
 #include "linden_common.h"
-#include <openssl/x509_vfy.h>
+
 #include "llhttpclient.h"
 
 #include "llassetstorage.h"
@@ -40,10 +40,8 @@
 #include "message.h"
 #include <curl/curl.h>
 
-
 const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
 LLURLRequest::SSLCertVerifyCallback LLHTTPClient::mCertVerifyCallback = NULL;
-
 ////////////////////////////////////////////////////////////////////////////
 
 // Responder class moved to LLCurl
@@ -158,9 +156,9 @@ namespace
 			if(fstream.is_open())
 			{
 				fstream.seekg(0, std::ios::end);
-				U32 fileSize = fstream.tellg();
+				U32 fileSize = (U32)fstream.tellg();
 				fstream.seekg(0, std::ios::beg);
-				std::vector<char> fileBuffer(fileSize);
+				std::vector<char> fileBuffer(fileSize); //Mem leak fix'd
 				fstream.read(&fileBuffer[0], fileSize);
 				ostream.write(&fileBuffer[0], fileSize);
 				fstream.close();
@@ -189,11 +187,9 @@ namespace
 			
 			LLVFile vfile(gVFS, mUUID, mAssetType, LLVFile::READ);
 			S32 fileSize = vfile.getSize();
-			U8* fileBuffer;
+			std::vector<U8> fileBuffer(fileSize);
-			fileBuffer = new U8 [fileSize];
+			vfile.read(&fileBuffer[0], fileSize);
-            vfile.read(fileBuffer, fileSize);
+			ostream.write((char*)&fileBuffer[0], fileSize);
-            ostream.write((char*)fileBuffer, fileSize);
-			delete [] fileBuffer;
 			eos = true;
 			return STATUS_DONE;
 		}
@@ -202,7 +198,6 @@ namespace
 		LLAssetType::EType mAssetType;
 	};
 
-	
 	LLPumpIO* theClientPump = NULL;
 }
 
@@ -217,8 +212,7 @@ static void request(
 	Injector* body_injector,
 	LLCurl::ResponderPtr responder,
 	const F32 timeout = HTTP_REQUEST_EXPIRY_SECS,
-	const LLSD& headers = LLSD()
+	const LLSD& headers = LLSD())
-    )
 {
 	if (!LLHTTPClient::hasPump())
 	{
@@ -228,26 +222,12 @@ static void request(
 	LLPumpIO::chain_t chain;
 
 	LLURLRequest* req = new LLURLRequest(method, url);
-	if(!req->isValid())//failed
-	{
-		delete req ;
-		return ;
-	}
 
 	req->setSSLVerifyCallback(LLHTTPClient::getCertVerifyCallback(), (void *)req);
 
-	
+    // Insert custom headers is the caller sent any
-	lldebugs << LLURLRequest::actionAsVerb(method) << " " << url << " "
-		<< headers << llendl;
-
-	// Insert custom headers if the caller sent any
     if (headers.isMap())
     {
-		if (headers.has("Cookie"))
-		{
-			req->allowCookies();
-		}
-
         LLSD::map_const_iterator iter = headers.beginMap();
         LLSD::map_const_iterator end  = headers.endMap();
 
@@ -429,17 +409,12 @@ static LLSD blocking_request(
 {
 	lldebugs << "blockingRequest of " << url << llendl;
 	char curl_error_buffer[CURL_ERROR_SIZE] = "\0";
-	CURL* curlp = LLCurl::newEasyHandle();
+	CURL* curlp = curl_easy_init();
-	llassert_always(curlp != NULL) ;
-
 	LLHTTPBuffer http_buffer;
 	std::string body_str;
 	
 	// other request method checks root cert first, we skip?
 	
-	// Apply configured proxy settings
-	LLProxy::getInstance()->applyProxySettings(curlp);
-	
 	// * Set curl handle options
 	curl_easy_setopt(curlp, CURLOPT_NOSIGNAL, 1);	// don't use SIGALRM for timeouts
 	curl_easy_setopt(curlp, CURLOPT_TIMEOUT, timeout);	// seconds, see warning at top of function.
@@ -525,7 +500,7 @@ static LLSD blocking_request(
 	}
 
 	// * Cleanup
-	LLCurl::deleteEasyHandle(curlp);
+	curl_easy_cleanup(curlp);
 	return response;
 }
 
@@ -625,7 +600,6 @@ bool LLHTTPClient::hasPump()
 	return theClientPump != NULL;
 }
 
-//static
 LLPumpIO &LLHTTPClient::getPump()
 {
 	return *theClientPump;

indra/llmessage/llhttpclient.h

@@ -34,10 +34,11 @@
 #include <string>
 
 #include <boost/intrusive_ptr.hpp>
-#include "llurlrequest.h"
+
 #include "llassettype.h"
 #include "llcurl.h"
 #include "lliopipe.h"
+#include "llurlrequest.h"
 
 extern const F32 HTTP_REQUEST_EXPIRY_SECS;
 
@@ -55,7 +56,6 @@ public:
 	typedef LLCurl::Responder Responder;
 	typedef LLCurl::ResponderPtr ResponderPtr;
 
-	
 	/** @name non-blocking API */
 	//@{
 	static void head(

indra/llmessage/lliohttpserver.cpp

@@ -33,7 +33,6 @@
 #include "llapr.h"
 #include "llbuffer.h"
 #include "llbufferstream.h"
-#include "llfasttimer.h"
 #include "llhttpnode.h"
 #include "lliopipe.h"
 #include "lliosocket.h"

indra/llmessage/lliosocket.cpp

@@ -32,7 +32,6 @@
 #include "llapr.h"
 
 #include "llbuffer.h"
-#include "llfasttimer.h"
 #include "llhost.h"
 #include "llmemtype.h"
 #include "llpumpio.h"

indra/llmessage/lliosocket.h

@@ -37,6 +37,7 @@
  * OS poll indicates it will not block.
  */
 
+#include "llaprpool.h"
 #include "lliopipe.h"
 #include "apr_network_io.h"
 #include "llchainio.h"

indra/llmessage/llioutil.cpp

@@ -27,8 +27,8 @@
  */
 
 #include "linden_common.h"
-#include "llfasttimer.h"
 #include "llioutil.h"
+#include "llfasttimer.h"
 
 /**
  * LLIOFlush

indra/llmessage/llmail.cpp

@@ -50,7 +50,6 @@
 #include "llstring.h"
 #include "lluuid.h"
 #include "net.h"
-#include "llaprpool.h"
 
 //
 // constants
@@ -58,7 +57,7 @@
 const size_t LL_MAX_KNOWN_GOOD_MAIL_SIZE = 4096;
 
 static bool gMailEnabled = true;
-static LLAPRPool gMailPool;
+static apr_pool_t* gMailPool;
 static apr_sockaddr_t* gSockAddr;
 static apr_socket_t* gMailSocket;
 
@@ -83,7 +82,7 @@ bool connect_smtp()
 		gSockAddr->sa.sin.sin_family,
 		SOCK_STREAM,
 		APR_PROTO_TCP,
-		gMailPool());
+		gMailPool);
 	if(ll_apr_warn_status(status)) return false;
 	status = apr_socket_connect(gMailSocket, gSockAddr);
 	if(ll_apr_warn_status(status))
@@ -140,19 +139,19 @@ BOOL LLMail::send(
 }
 
 // static
-void LLMail::init(const std::string& hostname)
+void LLMail::init(const std::string& hostname, apr_pool_t* pool)
 {
 	gMailSocket = NULL;
-	if (hostname.empty())
+	if(hostname.empty() || !pool)
 	{
+		gMailPool = NULL;
 		gSockAddr = NULL;
-		gMailPool.destroy();
 	}
 	else
 	{
-		gMailPool.create();
+		gMailPool = pool;
 
-		// Collect all the information into a sockaddr structure. the
+		// collect all the information into a socaddr sturcture. the
 		// documentation is a bit unclear, but I either have to
 		// specify APR_UNSPEC or not specify any flags. I am not sure
 		// which option is better.
@@ -162,7 +161,7 @@ void LLMail::init(const std::string& hostname)
 			APR_UNSPEC,
 			25,
 			APR_IPV4_ADDR_OK,
-			gMailPool());
+			gMailPool);
 		ll_apr_warn_status(status);
 	}
 }

indra/llmessage/llmail.h

@@ -27,13 +27,15 @@
 #ifndef LL_LLMAIL_H
 #define LL_LLMAIL_H
 
+typedef struct apr_pool_t apr_pool_t;
+
 #include "llsd.h"
 
 class LLMail
 {
 public:
 	// if hostname is NULL, then the host is resolved as 'mail'
-	static void init(const std::string& hostname);
+	static void init(const std::string& hostname, apr_pool_t* pool);
 
 	// Allow all email transmission to be disabled/enabled.
 	static void enable(bool mail_enabled);

indra/llmessage/llmime.cpp

@@ -388,7 +388,7 @@ bool LLMimeParser::Impl::parseHeaders(
 		// not to read past limit when we get() the newline.
 		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
 		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += istr.gcount();
+		mScanCount += (S32)istr.gcount();
 		int c = istr.get();
 		if(EOF == c)
 		{
@@ -496,7 +496,7 @@ void LLMimeParser::Impl::scanPastSeparator(
 		// past limit when we get() the newline.
 		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
 		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += istr.gcount();
+		mScanCount += (S32)istr.gcount();
 		if(istr.gcount() >= LINE_BUFFER_LENGTH - 1)
 		{
 			// that's way too long to be a separator, so ignore it.

indra/llmessage/llpumpio.cpp

@@ -4,25 +4,31 @@
  * @date 2004-11-21
  * @brief Implementation of the i/o pump and related functions.
  *
- * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
+ * There are special exceptions to the terms and conditions of the GPL as
- * modify it under the terms of the GNU Lesser General Public
+ * it is applied to this Source Code. View the full text of the exception
- * License as published by the Free Software Foundation;
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
- * version 2.1 of the License only.
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
+ * By copying, modifying or distributing this software, you acknowledge
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * that you have read and understood your obligations described above,
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * and agree to abide by those obligations.
- * Lesser General Public License for more details.
  * 
- * You should have received a copy of the GNU Lesser General Public
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * License along with this library; if not, write to the Free Software
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * COMPLETENESS OR PERFORMANCE.
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
@@ -34,11 +40,12 @@
 #include "apr_poll.h"
 
 #include "llapr.h"
-#include "llfasttimer.h"
 #include "llmemtype.h"
 #include "llstl.h"
 #include "llstat.h"
 #include "llthread.h"
+#include "llfasttimer.h"
+#include <iterator> //VS2010
 
 // These should not be enabled in production, but they can be
 // intensely useful during development for finding certain kinds of
@@ -184,21 +191,10 @@ LLPumpIO::LLPumpIO(void) :
 LLPumpIO::~LLPumpIO()
 {
 	LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-#if LL_THREADS_APR
+	cleanup();
-	if (mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
-	if (mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
-#endif
-	mChainsMutex = NULL;
-	mCallbackMutex = NULL;
-	if(mPollset)
-	{
-//		lldebugs << "cleaning up pollset" << llendl;
-		apr_pollset_destroy(mPollset);
-		mPollset = NULL;
-	}
 }
 
-bool LLPumpIO::addChain(const chain_t& chain, F32 timeout, bool has_curl_request)
+bool LLPumpIO::addChain(const chain_t& chain, F32 timeout)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_PUMP);
 	if(chain.empty()) return false;
@@ -207,10 +203,8 @@ bool LLPumpIO::addChain(const chain_t& chain, F32 timeout, bool has_curl_request
 	LLScopedLock lock(mChainsMutex);
 #endif
 	LLChainInfo info;
-	info.mHasCurlRequest = has_curl_request;
 	info.setTimeoutSeconds(timeout);
 	info.mData = LLIOPipe::buffer_ptr_t(new LLBufferArray);
-	info.mData->setThreaded(has_curl_request);
 	LLLinkInfo link;
 #if LL_DEBUG_PIPE_TYPE_IN_PUMP
 	lldebugs << "LLPumpIO::addChain() " << chain[0] << " '"
@@ -444,15 +438,6 @@ void LLPumpIO::pump()
 
 static LLFastTimer::DeclareTimer FTM_PUMP_IO("Pump IO");
 
-LLPumpIO::current_chain_t LLPumpIO::removeRunningChain(LLPumpIO::current_chain_t& run_chain) 
-{
-	std::for_each(
-				(*run_chain).mDescriptors.begin(),
-				(*run_chain).mDescriptors.end(),
-				ll_delete_apr_pollset_fd_client_data());
-	return mRunningChains.erase(run_chain);
-}
-
 //timeout is in microseconds
 void LLPumpIO::pump(const S32& poll_timeout)
 {
@@ -598,16 +583,10 @@ void LLPumpIO::pump(const S32& poll_timeout)
 //						<< (*run_chain).mChainLinks[0].mPipe
 //						<< " because we reached the end." << llendl;
 #endif
-				run_chain = removeRunningChain(run_chain);
+				run_chain = mRunningChains.erase(run_chain);
 				continue;
 			}
 		}
-		else if(isChainExpired(*run_chain))
-		{
-			run_chain = removeRunningChain(run_chain);
-			continue;
-		}
-
 		PUMP_DEBUG;
 		if((*run_chain).mLock)
 		{
@@ -715,7 +694,11 @@ void LLPumpIO::pump(const S32& poll_timeout)
 			PUMP_DEBUG;
 			// This chain is done. Clean up any allocated memory and
 			// erase the chain info.
-			run_chain = removeRunningChain(run_chain);
+			std::for_each(
+				(*run_chain).mDescriptors.begin(),
+				(*run_chain).mDescriptors.end(),
+				ll_delete_apr_pollset_fd_client_data());
+			run_chain = mRunningChains.erase(run_chain);
 
 			// *NOTE: may not always need to rebuild the pollset.
 			mRebuildPollset = true;
@@ -850,6 +833,22 @@ void LLPumpIO::initialize(void)
 	apr_thread_mutex_create(&mCallbackMutex, APR_THREAD_MUTEX_UNNESTED, mPool());
 #endif
 }
+void LLPumpIO::cleanup()
+{
+	LLMemType m1(LLMemType::MTYPE_IO_PUMP);
+#if LL_THREADS_APR
+	if (mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
+	if (mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
+#endif
+	mChainsMutex = NULL;
+	mCallbackMutex = NULL;
+	if(mPollset)
+	{
+//		lldebugs << "cleaning up pollset" << llendl;
+		apr_pollset_destroy(mPollset);
+		mPollset = NULL;
+	}
+}
 
 void LLPumpIO::rebuildPollset()
 {
@@ -1084,24 +1083,6 @@ void LLPumpIO::processChain(LLChainInfo& chain)
 	PUMP_DEBUG;
 }
 
-bool LLPumpIO::isChainExpired(LLChainInfo& chain)
-{
-	if(!chain.mHasCurlRequest)
-	{
-		return false ;
-	}
-
-	for(links_t::iterator iter = chain.mChainLinks.begin(); iter != chain.mChainLinks.end(); ++iter)
-	{
-		if(!(*iter).mPipe->isValid())
-		{
-			return true ;
-		}
-	}
-
-	return false ;
-}
-
 bool LLPumpIO::handleChainError(
 	LLChainInfo& chain,
 	LLIOPipe::EStatus error)
@@ -1143,9 +1124,6 @@ bool LLPumpIO::handleChainError(
 #endif
 			keep_going = false;
 			break;
-		case LLIOPipe::STATUS_EXPIRED:
-			keep_going = false;
-			break ;
 		default:
 			if(LLIOPipe::isSuccess(error))
 			{
@@ -1168,7 +1146,6 @@ LLPumpIO::LLChainInfo::LLChainInfo() :
 	mInit(false),
 	mLock(0),
 	mEOS(false),
-	mHasCurlRequest(false),
 	mDescriptorsPool(new LLAPRPool(LLThread::tldata().mRootPool))
 {
 	LLMemType m1(LLMemType::MTYPE_IO_PUMP);
@@ -1180,9 +1157,7 @@ void LLPumpIO::LLChainInfo::setTimeoutSeconds(F32 timeout)
 	LLMemType m1(LLMemType::MTYPE_IO_PUMP);
 	if(timeout > 0.0f)
 	{
-		mTimer.start();
+		mTimer.start(timeout);
-		mTimer.reset();
-		mTimer.setTimerExpirySec(timeout);
 	}
 	else
 	{

indra/llmessage/llpumpio.h

@@ -4,25 +4,31 @@
  * @date 2004-11-19
  * @brief Declaration of pump class which manages io chains.
  *
- * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
+ * There are special exceptions to the terms and conditions of the GPL as
- * modify it under the terms of the GNU Lesser General Public
+ * it is applied to this Source Code. View the full text of the exception
- * License as published by the Free Software Foundation;
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
- * version 2.1 of the License only.
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
+ * By copying, modifying or distributing this software, you acknowledge
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * that you have read and understood your obligations described above,
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * and agree to abide by those obligations.
- * Lesser General Public License for more details.
  * 
- * You should have received a copy of the GNU Lesser General Public
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * License along with this library; if not, write to the Free Software
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * COMPLETENESS OR PERFORMANCE.
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
@@ -100,10 +106,9 @@ public:
 	 * @param chain The pipes for the chain
 	 * @param timeout The number of seconds in the future to
 	 * expire. Pass in 0.0f to never expire.
-	 * @param has_curl_request The chain contains LLURLRequest if true.
 	 * @return Returns true if anything was added to the pump.
 	 */
-	bool addChain(const chain_t& chain, F32 timeout, bool has_curl_request = false);
+	bool addChain(const chain_t& chain, F32 timeout);
 	
 	/** 
 	 * @brief Struct to associate a pipe with it's buffer io indexes.
@@ -346,13 +351,12 @@ protected:
 
 		// basic member data
 		bool mInit;
-		bool mEOS;
-		bool mHasCurlRequest;
 		S32 mLock;
 		LLFrameTimer mTimer;
 		links_t::iterator mHead;
 		links_t mChainLinks;
 		LLIOPipe::buffer_ptr_t mData;
+		bool mEOS;
 		LLSD mContext;
 
 		// tracking inside the pump
@@ -393,8 +397,8 @@ protected:
 
 protected:
 	void initialize();
+	void cleanup();
 
-	current_chain_t removeRunningChain(current_chain_t& chain) ;
 	/** 
 	 * @brief Given the internal state of the chains, rebuild the pollset
 	 * @see setConditional()
@@ -421,9 +425,6 @@ protected:
 	 */
 	bool handleChainError(LLChainInfo& chain, LLIOPipe::EStatus error);
 
-	//if the chain is expired, remove it
-	bool isChainExpired(LLChainInfo& chain) ;
-
 public:
 	/** 
 	 * @brief Return number of running chains.

indra/llmessage/llsdmessage.cpp

@@ -88,7 +88,7 @@ bool LLSDMessage::httpListener(const LLSD& request)
                                                        request,
                                                        url, "POST", reply, error),
                        LLSD(),      // headers
-                       timeout);
+                       (F32)timeout);
     return false;
 }
 

indra/llmessage/llsdmessagebuilder.cpp

@@ -317,7 +317,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data)
 
 			// S64 not supported in LLSD so we just truncate it
 			case MVT_S64:
-				addS32(varname, *(S64*)mvci.getData());
+				addS32(varname, (S32)*(S64*)mvci.getData());
 				break;
 
 			case MVT_F32:

indra/llmessage/llurlrequest.cpp

@@ -32,17 +32,17 @@
 #include <algorithm>
 #include <openssl/x509_vfy.h>
 #include <openssl/ssl.h>
+
 #include "llcurl.h"
-#include "llfasttimer.h"
 #include "llioutil.h"
 #include "llmemtype.h"
-#include "llproxy.h"
 #include "llpumpio.h"
 #include "llsd.h"
 #include "llstring.h"
 #include "apr_env.h"
 #include "llapr.h"
 #include "llscopedvolatileaprpool.h"
+#include "llfasttimer.h"
 static const U32 HTTP_STATUS_PIPE_ERROR = 499;
 
 /**
@@ -66,7 +66,7 @@ public:
 	~LLURLRequestDetail();
 	std::string mURL;
 	LLCurlEasyRequest* mCurlRequest;
-	LLIOPipe::buffer_ptr_t mResponseBuffer;
+	LLBufferArray* mResponseBuffer;
 	LLChannelDescriptors mChannels;
 	U8* mLastRead;
 	U32 mBodyLimit;
@@ -77,26 +77,21 @@ public:
 
 LLURLRequestDetail::LLURLRequestDetail() :
 	mCurlRequest(NULL),
+	mResponseBuffer(NULL),
 	mLastRead(NULL),
 	mBodyLimit(0),
 	mByteAccumulator(0),
-	mIsBodyLimitSet(false),
+	mIsBodyLimitSet(false)
-    mSSLVerifyCallback(NULL)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	mCurlRequest = new LLCurlEasyRequest();
-	
-	if(!mCurlRequest->isValid()) //failed.
-	{
-		delete mCurlRequest ;
-		mCurlRequest = NULL ;
-	}
 }
 
 LLURLRequestDetail::~LLURLRequestDetail()
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	delete mCurlRequest;
+	mResponseBuffer = NULL;
 	mLastRead = NULL;
 }
 
@@ -128,7 +123,6 @@ CURLcode LLURLRequest::_sslCtxCallback(CURL * curl, void *sslctx, void *param)
 	SSL_CTX_set_cert_verify_callback(ctx, req->mDetail->mSSLVerifyCallback, (void *)req);
 	// the calls are void
 	return CURLE_OK;
-	
 }
 
 /**
@@ -189,7 +183,6 @@ std::string LLURLRequest::getURL() const
 {
 	return mDetail->mURL;
 }
-
 void LLURLRequest::addHeader(const char* header)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
@@ -240,9 +233,9 @@ void LLURLRequest::useProxy(bool use_proxy)
 		}
     }
 
-    lldebugs << "use_proxy = " << (use_proxy?'Y':'N') << ", env_proxy = \"" << env_proxy << "\"" << llendl;
+    LL_DEBUGS("Proxy") << "use_proxy = " << (use_proxy?'Y':'N') << ", env_proxy = " << (!env_proxy.empty() ? env_proxy : "(null)") << LL_ENDL;
 
-    if (use_proxy)
+    if (use_proxy && !env_proxy.empty())
     {
 		mDetail->mCurlRequest->setoptString(CURLOPT_PROXY, env_proxy);
     }
@@ -262,24 +255,12 @@ void LLURLRequest::allowCookies()
 	mDetail->mCurlRequest->setoptString(CURLOPT_COOKIEFILE, "");
 }
 
-//virtual 
-bool LLURLRequest::isValid() 
-{
-	return mDetail->mCurlRequest && mDetail->mCurlRequest->isValid(); 
-}
-
 // virtual
 LLIOPipe::EStatus LLURLRequest::handleError(
 	LLIOPipe::EStatus status,
 	LLPumpIO* pump)
 {
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
-	
-	if(!isValid())
-	{
-		return STATUS_EXPIRED ;
-	}
-
 	if(mCompletionCallback && pump)
 	{
 		LLURLRequestComplete* complete = NULL;
@@ -309,6 +290,7 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	//llinfos << "LLURLRequest::process_impl()" << llendl;
 	if (!buffer) return STATUS_ERROR;
+	if (!mDetail) return STATUS_ERROR; //Seems to happen on occasion. Need to hunt down why.
 
 	// we're still waiting or prcessing, check how many
 	// bytes we have accumulated.
@@ -348,7 +330,7 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
 
 		// *FIX: bit of a hack, but it should work. The configure and
 		// callback method expect this information to be ready.
-		mDetail->mResponseBuffer = buffer;
+		mDetail->mResponseBuffer = buffer.get();
 		mDetail->mChannels = channels;
 		if(!configure())
 		{
@@ -367,10 +349,7 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
 		static LLFastTimer::DeclareTimer FTM_URL_PERFORM("Perform");
 		{
 			LLFastTimer t(FTM_URL_PERFORM);
-			if(!mDetail->mCurlRequest->wait())
+			mDetail->mCurlRequest->perform();
-			{
-				return status ;
-			}
 		}
 
 		while(1)
@@ -465,12 +444,6 @@ void LLURLRequest::initialize()
 	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
 	mState = STATE_INITIALIZED;
 	mDetail = new LLURLRequestDetail;
-
-	if(!isValid())
-	{
-		return ;
-	}
-
 	mDetail->mCurlRequest->setopt(CURLOPT_NOSIGNAL, 1);
 	mDetail->mCurlRequest->setWriteCallback(&downCallback, (void*)this);
 	mDetail->mCurlRequest->setReadCallback(&upCallback, (void*)this);

indra/llmessage/llurlrequest.h

@@ -40,7 +40,6 @@
 #include "llerror.h"
 #include "llcurl.h"
 
-
 extern const std::string CONTEXT_REQUEST;
 extern const std::string CONTEXT_DEST_URI_SD_LABEL;
 extern const std::string CONTEXT_RESPONSE;
@@ -145,7 +144,6 @@ public:
 	 */
 	void setSSLVerifyCallback(SSLCertVerifyCallback callback, void * param);
 
-	
 	/**
 	 * @brief Return at most size bytes of body.
 	 *
@@ -190,15 +188,12 @@ public:
 	 */
 	void allowCookies();
 
-	/*virtual*/ bool isValid() ;
-
 public:
 	/** 
 	 * @brief Give this pipe a chance to handle a generated error
 	 */
 	virtual EStatus handleError(EStatus status, LLPumpIO* pump);
 	
-	
 protected:
 	/** 
 	 * @brief Process the data in buffer

indra/llmessage/llxfer.h

@@ -29,6 +29,7 @@
 
 #include "message.h"
 #include "lltimer.h"
+#include "llextendedstatus.h"
 
 const S32 LL_XFER_LARGE_PAYLOAD = 7680;
 

indra/llmessage/message.cpp

@@ -97,10 +97,8 @@ std::string get_shared_secret();
 class LLMessagePollInfo
 {
 public:
-	LLMessagePollInfo(void) : mPool(LLThread::tldata().mRootPool) { }
 	apr_socket_t *mAPRSocketp;
 	apr_pollfd_t mPollFD;
-	LLAPRPool mPool;
 };
 
 namespace
@@ -289,13 +287,15 @@ LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port,
 	}
 //	LL_DEBUGS("Messaging") <<  << "*** port: " << mPort << llendl;
 
-	mPollInfop = new LLMessagePollInfo;
+	//
-
+	// Create the data structure that we can poll on
+	//
 	apr_socket_t *aprSocketp = NULL;
-	apr_os_sock_put(&aprSocketp, (apr_os_sock_t*)&mSocket, mPollInfop->mPool());
+	apr_os_sock_put(&aprSocketp, (apr_os_sock_t*)&mSocket, LLAPRRootPool::get()());
 
+	mPollInfop = new LLMessagePollInfo;
 	mPollInfop->mAPRSocketp = aprSocketp;
-	mPollInfop->mPollFD.p = mPollInfop->mPool();
+	mPollInfop->mPollFD.p = LLAPRRootPool::get()();
 	mPollInfop->mPollFD.desc_type = APR_POLL_SOCKET;
 	mPollInfop->mPollFD.reqevents = APR_POLLIN;
 	mPollInfop->mPollFD.rtnevents = 0;
@@ -3142,7 +3142,7 @@ bool LLMessageSystem::generateDigestForWindowAndUUIDs(char* digest, const S32 wi
 		LL_ERRS("Messaging") << "Trying to generate complex digest on a machine without a shared secret!" << llendl;
 	}
 
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 
@@ -3162,7 +3162,7 @@ bool LLMessageSystem::isMatchingDigestForWindowAndUUIDs(const char* digest, cons
 	}
 	
 	char our_digest[MD5HEX_STR_SIZE];	/* Flawfinder: ignore */
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 
@@ -3208,7 +3208,7 @@ bool LLMessageSystem::generateDigestForWindow(char* digest, const S32 window) co
 		LL_ERRS("Messaging") << "Trying to generate simple digest on a machine without a shared secret!" << llendl;
 	}
 
-	U32 now = time(NULL);
+	U32 now = (U32)time(NULL);
 
 	now /= window;
 

indra/llplugin/slplugin/CMakeLists.txt

@@ -55,7 +55,6 @@ set_target_properties(SLPlugin
   )
 
 target_link_libraries(SLPlugin
-  ${GOOGLE_PERFTOOLS_LIBRARIES}
   ${LLPLUGIN_LIBRARIES}
   ${LLMESSAGE_LIBRARIES}
   ${LLCOMMON_LIBRARIES}
@@ -82,11 +81,4 @@ if (DARWIN)
   )
 endif (DARWIN)
 
-if (WINDOWS)
-    set_target_properties(SLPlugin
-      PROPERTIES
-        LINK_FLAGS "${GOOGLE_PERFTOOLS_LINKER_FLAGS}"
-        )
-endif (WINDOWS)
-
 #ll_deploy_sharedlibs_command(SLPlugin)

indra/llprimitive/CMakeLists.txt

@@ -17,6 +17,7 @@ include_directories(
 
 set(llprimitive_SOURCE_FILES
     llmaterialtable.cpp
+    llmediaentry.cpp
     llmodel.cpp
     llprimitive.cpp
     llprimtexturelist.cpp

indra/llprimitive/llmaterialtable.cpp

@@ -137,6 +137,7 @@ void LLMaterialTable::initTableTransNames(std::map<std::string, std::string> nam
 		infop->mName = namemap[name];
 	}
 }
+
 void LLMaterialTable::initBasicTable()
 {
 	// *TODO: Translate

indra/llprimitive/llmediaentry.cpp

@@ -0,0 +1,596 @@
+/** 
+ * @file llmediaentry.cpp
+ * @brief This is a single instance of media data related to the face of a prim
+ *
+ * $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$
+ */
+
+#include "linden_common.h"
+#include "llmediaentry.h"
+#include "lllslconstants.h"
+
+#include <boost/regex.hpp>
+
+// LLSD key defines
+// DO NOT REORDER OR REMOVE THESE!
+
+// Some LLSD keys.  Do not change!
+#define MEDIA_ALT_IMAGE_ENABLE_KEY_STR   "alt_image_enable"
+#define MEDIA_CONTROLS_KEY_STR           "controls"
+#define MEDIA_CURRENT_URL_KEY_STR        "current_url"
+#define MEDIA_HOME_URL_KEY_STR           "home_url"
+#define MEDIA_AUTO_LOOP_KEY_STR          "auto_loop"
+#define MEDIA_AUTO_PLAY_KEY_STR          "auto_play"
+#define MEDIA_AUTO_SCALE_KEY_STR         "auto_scale"
+#define MEDIA_AUTO_ZOOM_KEY_STR          "auto_zoom"
+#define MEDIA_FIRST_CLICK_INTERACT_KEY_STR  "first_click_interact"
+#define MEDIA_WIDTH_PIXELS_KEY_STR       "width_pixels"
+#define MEDIA_HEIGHT_PIXELS_KEY_STR      "height_pixels"
+
+// "security" fields
+#define MEDIA_WHITELIST_ENABLE_KEY_STR   "whitelist_enable"
+#define MEDIA_WHITELIST_KEY_STR          "whitelist"
+
+// "permissions" fields
+#define MEDIA_PERMS_INTERACT_KEY_STR     "perms_interact"
+#define MEDIA_PERMS_CONTROL_KEY_STR      "perms_control"
+
+// "general" fields
+const char* LLMediaEntry::ALT_IMAGE_ENABLE_KEY  = MEDIA_ALT_IMAGE_ENABLE_KEY_STR;
+const char* LLMediaEntry::CONTROLS_KEY          = MEDIA_CONTROLS_KEY_STR;
+const char* LLMediaEntry::CURRENT_URL_KEY       = MEDIA_CURRENT_URL_KEY_STR;
+const char* LLMediaEntry::HOME_URL_KEY          = MEDIA_HOME_URL_KEY_STR;
+const char* LLMediaEntry::AUTO_LOOP_KEY         = MEDIA_AUTO_LOOP_KEY_STR;
+const char* LLMediaEntry::AUTO_PLAY_KEY         = MEDIA_AUTO_PLAY_KEY_STR;
+const char* LLMediaEntry::AUTO_SCALE_KEY        = MEDIA_AUTO_SCALE_KEY_STR;
+const char* LLMediaEntry::AUTO_ZOOM_KEY         = MEDIA_AUTO_ZOOM_KEY_STR;
+const char* LLMediaEntry::FIRST_CLICK_INTERACT_KEY = MEDIA_FIRST_CLICK_INTERACT_KEY_STR;
+const char* LLMediaEntry::WIDTH_PIXELS_KEY      = MEDIA_WIDTH_PIXELS_KEY_STR;
+const char* LLMediaEntry::HEIGHT_PIXELS_KEY     = MEDIA_HEIGHT_PIXELS_KEY_STR;
+
+// "security" fields
+const char* LLMediaEntry::WHITELIST_ENABLE_KEY  = MEDIA_WHITELIST_ENABLE_KEY_STR;
+const char* LLMediaEntry::WHITELIST_KEY         = MEDIA_WHITELIST_KEY_STR;
+
+// "permissions" fields
+const char* LLMediaEntry::PERMS_INTERACT_KEY    = MEDIA_PERMS_INTERACT_KEY_STR;
+const char* LLMediaEntry::PERMS_CONTROL_KEY     = MEDIA_PERMS_CONTROL_KEY_STR;
+
+#define DEFAULT_URL_PREFIX  "http://"
+
+// Constructor(s)
+LLMediaEntry::LLMediaEntry() :
+    mAltImageEnable(false),
+    mControls(STANDARD),
+    mCurrentURL(""),
+    mHomeURL(""),
+    mAutoLoop(false),
+    mAutoPlay(false),
+    mAutoScale(false),
+    mAutoZoom(false),
+    mFirstClickInteract(false),
+    mWidthPixels(0),
+    mHeightPixels(0),
+    mWhiteListEnable(false),
+    // mWhiteList
+    mPermsInteract(PERM_ALL),
+    mPermsControl(PERM_ALL),
+    mMediaIDp(NULL)
+{
+}
+
+LLMediaEntry::LLMediaEntry(const LLMediaEntry &rhs) :
+    mMediaIDp(NULL)
+{
+    // "general" fields
+    mAltImageEnable = rhs.mAltImageEnable;
+    mControls = rhs.mControls;
+    mCurrentURL = rhs.mCurrentURL;
+    mHomeURL = rhs.mHomeURL;
+    mAutoLoop = rhs.mAutoLoop;
+    mAutoPlay = rhs.mAutoPlay;
+    mAutoScale = rhs.mAutoScale;
+    mAutoZoom = rhs.mAutoZoom;
+    mFirstClickInteract = rhs.mFirstClickInteract;
+    mWidthPixels = rhs.mWidthPixels;
+    mHeightPixels = rhs.mHeightPixels;
+
+    // "security" fields
+    mWhiteListEnable = rhs.mWhiteListEnable;
+    mWhiteList = rhs.mWhiteList;
+
+    // "permissions" fields
+    mPermsInteract = rhs.mPermsInteract;
+    mPermsControl = rhs.mPermsControl;
+}
+
+LLMediaEntry::~LLMediaEntry()
+{
+    if (NULL != mMediaIDp)
+    {
+        delete mMediaIDp;
+    }
+}
+
+LLSD LLMediaEntry::asLLSD() const
+{
+    LLSD sd;
+    asLLSD(sd);
+    return sd;
+}
+
+//
+// LLSD functions
+//
+void LLMediaEntry::asLLSD(LLSD& sd) const
+{
+    // "general" fields
+    sd[ALT_IMAGE_ENABLE_KEY] = mAltImageEnable;
+    sd[CONTROLS_KEY] = (LLSD::Integer)mControls;
+    sd[CURRENT_URL_KEY] = mCurrentURL;
+    sd[HOME_URL_KEY] = mHomeURL;
+    sd[AUTO_LOOP_KEY] = mAutoLoop;
+    sd[AUTO_PLAY_KEY] = mAutoPlay;
+    sd[AUTO_SCALE_KEY] = mAutoScale;
+    sd[AUTO_ZOOM_KEY] = mAutoZoom;
+    sd[FIRST_CLICK_INTERACT_KEY] = mFirstClickInteract;
+    sd[WIDTH_PIXELS_KEY] = mWidthPixels;
+    sd[HEIGHT_PIXELS_KEY] = mHeightPixels;
+
+    // "security" fields
+    sd[WHITELIST_ENABLE_KEY] = mWhiteListEnable;
+	sd.erase(WHITELIST_KEY);
+    for (U32 i=0; i<mWhiteList.size(); i++) 
+	{
+        sd[WHITELIST_KEY].append(mWhiteList[i]);
+    }
+
+    // "permissions" fields
+    sd[PERMS_INTERACT_KEY] = mPermsInteract;
+    sd[PERMS_CONTROL_KEY] = mPermsControl;
+}
+
+// static
+bool LLMediaEntry::checkLLSD(const LLSD& sd)
+{
+    if (sd.isUndefined()) return true;
+    LLMediaEntry temp;
+    return temp.fromLLSDInternal(sd, true);
+}
+
+void LLMediaEntry::fromLLSD(const LLSD& sd)
+{
+    (void)fromLLSDInternal(sd, true);
+}
+
+void LLMediaEntry::mergeFromLLSD(const LLSD& sd)
+{
+    (void)fromLLSDInternal(sd, false);
+}
+
+// *NOTE: returns true if NO failures to set occurred, false otherwise.
+//        However, be aware that if a failure to set does occur, it does
+//        not stop setting fields from the LLSD!
+bool LLMediaEntry::fromLLSDInternal(const LLSD& sd, bool overwrite)
+{
+    // *HACK: we sort of cheat here and assume that status is a
+    // bit field.  We "or" into status and instead of returning
+    // it, we return whether it finishes off as LSL_STATUS_OK or not.
+    U32 status = LSL_STATUS_OK;
+    
+    // "general" fields
+    if ( overwrite || sd.has(ALT_IMAGE_ENABLE_KEY) )
+    {
+        status |= setAltImageEnable( sd[ALT_IMAGE_ENABLE_KEY] );
+    }
+    if ( overwrite || sd.has(CONTROLS_KEY) )
+    {
+        status |= setControls( (MediaControls)(LLSD::Integer)sd[CONTROLS_KEY] );
+    }
+    if ( overwrite || sd.has(CURRENT_URL_KEY) )
+    {
+        // Don't check whitelist
+        status |= setCurrentURLInternal( sd[CURRENT_URL_KEY], false );
+    }
+    if ( overwrite || sd.has(HOME_URL_KEY) )
+    {
+        status |= setHomeURL( sd[HOME_URL_KEY] );
+    }
+    if ( overwrite || sd.has(AUTO_LOOP_KEY) )
+    {
+        status |= setAutoLoop( sd[AUTO_LOOP_KEY] );
+    }
+    if ( overwrite || sd.has(AUTO_PLAY_KEY) )
+    {
+        status |= setAutoPlay( sd[AUTO_PLAY_KEY] );
+    }
+    if ( overwrite || sd.has(AUTO_SCALE_KEY) )
+    {
+        status |= setAutoScale( sd[AUTO_SCALE_KEY] );
+    }
+    if ( overwrite || sd.has(AUTO_ZOOM_KEY) )
+    {
+        status |= setAutoZoom( sd[AUTO_ZOOM_KEY] );
+    }
+    if ( overwrite || sd.has(FIRST_CLICK_INTERACT_KEY) )
+    {
+        status |= setFirstClickInteract( sd[FIRST_CLICK_INTERACT_KEY] );
+    }
+    if ( overwrite || sd.has(WIDTH_PIXELS_KEY) )
+    {
+        status |= setWidthPixels( (LLSD::Integer)sd[WIDTH_PIXELS_KEY] );
+    }
+    if ( overwrite || sd.has(HEIGHT_PIXELS_KEY) )
+    {
+        status |= setHeightPixels( (LLSD::Integer)sd[HEIGHT_PIXELS_KEY] );
+    }
+
+    // "security" fields
+    if ( overwrite || sd.has(WHITELIST_ENABLE_KEY) )
+    {
+        status |= setWhiteListEnable( sd[WHITELIST_ENABLE_KEY] );
+    }
+    if ( overwrite || sd.has(WHITELIST_KEY) )
+    {
+        status |= setWhiteList( sd[WHITELIST_KEY] );
+    }
+
+    // "permissions" fields
+    if ( overwrite || sd.has(PERMS_INTERACT_KEY) )
+    {
+        status |= setPermsInteract( 0xff & (LLSD::Integer)sd[PERMS_INTERACT_KEY] );
+    }
+    if ( overwrite || sd.has(PERMS_CONTROL_KEY) )
+    {
+        status |= setPermsControl( 0xff & (LLSD::Integer)sd[PERMS_CONTROL_KEY] );
+    }
+    
+    return LSL_STATUS_OK == status;
+}
+
+LLMediaEntry& LLMediaEntry::operator=(const LLMediaEntry &rhs)
+{
+    if (this != &rhs)
+    {
+        // "general" fields
+        mAltImageEnable = rhs.mAltImageEnable;
+        mControls = rhs.mControls;
+        mCurrentURL = rhs.mCurrentURL;
+        mHomeURL = rhs.mHomeURL;
+        mAutoLoop = rhs.mAutoLoop;
+        mAutoPlay = rhs.mAutoPlay;
+        mAutoScale = rhs.mAutoScale;
+        mAutoZoom = rhs.mAutoZoom;
+        mFirstClickInteract = rhs.mFirstClickInteract;
+        mWidthPixels = rhs.mWidthPixels;
+        mHeightPixels = rhs.mHeightPixels;
+
+        // "security" fields
+        mWhiteListEnable = rhs.mWhiteListEnable;
+        mWhiteList = rhs.mWhiteList;
+
+        // "permissions" fields
+        mPermsInteract = rhs.mPermsInteract;
+        mPermsControl = rhs.mPermsControl;
+    }
+
+    return *this;
+}
+
+bool LLMediaEntry::operator==(const LLMediaEntry &rhs) const
+{
+    return (
+        // "general" fields
+        mAltImageEnable == rhs.mAltImageEnable &&
+        mControls == rhs.mControls &&
+        mCurrentURL == rhs.mCurrentURL &&
+        mHomeURL == rhs.mHomeURL &&
+        mAutoLoop == rhs.mAutoLoop &&
+        mAutoPlay == rhs.mAutoPlay &&
+        mAutoScale == rhs.mAutoScale &&
+        mAutoZoom == rhs.mAutoZoom &&
+        mFirstClickInteract == rhs.mFirstClickInteract &&
+        mWidthPixels == rhs.mWidthPixels &&
+        mHeightPixels == rhs.mHeightPixels &&
+
+        // "security" fields
+        mWhiteListEnable == rhs.mWhiteListEnable &&
+        mWhiteList == rhs.mWhiteList &&
+
+        // "permissions" fields
+        mPermsInteract == rhs.mPermsInteract &&
+        mPermsControl == rhs.mPermsControl
+
+        );
+}
+ 
+bool LLMediaEntry::operator!=(const LLMediaEntry &rhs) const
+{
+    return (
+        // "general" fields
+        mAltImageEnable != rhs.mAltImageEnable ||
+        mControls != rhs.mControls ||
+        mCurrentURL != rhs.mCurrentURL ||
+        mHomeURL != rhs.mHomeURL ||
+        mAutoLoop != rhs.mAutoLoop ||
+        mAutoPlay != rhs.mAutoPlay ||
+        mAutoScale != rhs.mAutoScale ||
+        mAutoZoom != rhs.mAutoZoom ||
+        mFirstClickInteract != rhs.mFirstClickInteract ||
+        mWidthPixels != rhs.mWidthPixels ||
+        mHeightPixels != rhs.mHeightPixels ||
+
+        // "security" fields
+        mWhiteListEnable != rhs.mWhiteListEnable ||
+        mWhiteList != rhs.mWhiteList ||
+
+        // "permissions" fields
+        mPermsInteract != rhs.mPermsInteract ||
+        mPermsControl != rhs.mPermsControl 
+        
+        );
+}
+
+U32 LLMediaEntry::setWhiteList( const std::vector<std::string> &whitelist )
+{
+    // *NOTE: This code is VERY similar to the setWhitelist below.
+    // IF YOU CHANGE THIS IMPLEMENTATION, BE SURE TO CHANGE THE OTHER!
+    U32 size = 0;
+    U32 count = 0;
+    // First count to make sure the size constraint is not violated
+    std::vector<std::string>::const_iterator iter = whitelist.begin();
+    std::vector<std::string>::const_iterator end = whitelist.end();
+    for ( ; iter < end; ++iter) 
+    {
+        const std::string &entry = (*iter);
+        size += entry.length() + 1; // Include one for \0
+        count ++;
+        if (size > MAX_WHITELIST_SIZE || count > MAX_WHITELIST_COUNT) 
+		{
+            return LSL_STATUS_BOUNDS_ERROR;
+        }
+    }
+    // Next clear the vector
+    mWhiteList.clear();
+    // Then re-iterate and copy entries
+    iter = whitelist.begin();
+    for ( ; iter < end; ++iter)
+    {
+        const std::string &entry = (*iter);
+        mWhiteList.push_back(entry);
+    }
+    return LSL_STATUS_OK;
+}
+
+U32 LLMediaEntry::setWhiteList( const LLSD &whitelist )
+{
+    // If whitelist is undef, the whitelist is cleared
+    if (whitelist.isUndefined()) 
+	{
+		mWhiteList.clear();
+		return LSL_STATUS_OK;
+	}
+
+    // However, if the whitelist is an empty array, erase it.
+    if (whitelist.isArray()) 
+    {
+        // *NOTE: This code is VERY similar to the setWhitelist above.
+        // IF YOU CHANGE THIS IMPLEMENTATION, BE SURE TO CHANGE THE OTHER!
+        U32 size = 0;
+        U32 count = 0;
+        // First check to make sure the size and count constraints are not violated
+        LLSD::array_const_iterator iter = whitelist.beginArray();
+        LLSD::array_const_iterator end = whitelist.endArray();
+        for ( ; iter < end; ++iter) 
+        {
+            const std::string &entry = (*iter).asString();
+            size += entry.length() + 1; // Include one for \0
+            count ++;
+            if (size > MAX_WHITELIST_SIZE || count > MAX_WHITELIST_COUNT) 
+			{
+                return LSL_STATUS_BOUNDS_ERROR;
+            }
+        }
+        // Next clear the vector
+        mWhiteList.clear();
+        // Then re-iterate and copy entries
+        iter = whitelist.beginArray();
+        for ( ; iter < end; ++iter)
+        {
+            const std::string &entry = (*iter).asString();
+            mWhiteList.push_back(entry);
+        }
+        return LSL_STATUS_OK;
+    }
+    else 
+	{
+        return LSL_STATUS_MALFORMED_PARAMS;
+    }
+}
+
+
+static void prefix_with(std::string &str, const char *chars, const char *prefix)
+{
+    // Given string 'str', prefix all instances of any character in 'chars'
+    // with 'prefix'
+    size_t found = str.find_first_of(chars);
+    size_t prefix_len = strlen(prefix);
+    while (found != std::string::npos)
+    {
+        str.insert(found, prefix, prefix_len);
+        found = str.find_first_of(chars, found+prefix_len+1);
+    }
+}
+
+static bool pattern_match(const std::string &candidate_str, const std::string &pattern)
+{
+    // If the pattern is empty, it matches
+    if (pattern.empty()) return true;
+    
+    // 'pattern' is a glob pattern, we only accept '*' chars
+    // copy it
+    std::string expression = pattern;
+    
+    // Escape perl's regexp chars with a backslash, except all "*" chars
+    prefix_with(expression, ".[{()\\+?|^$", "\\");
+    prefix_with(expression, "*", ".");
+                    
+    // case-insensitive matching:
+    boost::regex regexp(expression, boost::regex::perl|boost::regex::icase);
+    return boost::regex_match(candidate_str, regexp);
+}
+
+bool LLMediaEntry::checkCandidateUrl(const std::string& url) const
+{
+    if (getWhiteListEnable()) 
+    {
+        return checkUrlAgainstWhitelist(url, getWhiteList());
+    }
+    else 
+	{
+        return true;
+    }
+}
+
+// static
+bool LLMediaEntry::checkUrlAgainstWhitelist(const std::string& url, 
+                                            const std::vector<std::string> &whitelist)
+{
+    bool passes = true;
+    // *NOTE: no entries?  Don't check
+    if (whitelist.size() > 0) 
+    {
+        passes = false;
+            
+        // Case insensitive: the reason why we toUpper both this and the
+        // filter
+        std::string candidate_url = url;
+        // Use lluri to see if there is a path part in the candidate URL.  No path?  Assume "/"
+        LLURI candidate_uri(candidate_url);
+        std::vector<std::string>::const_iterator iter = whitelist.begin();
+        std::vector<std::string>::const_iterator end = whitelist.end();
+        for ( ; iter < end; ++iter )
+        {
+            std::string filter = *iter;
+                
+            LLURI filter_uri(filter);
+            bool scheme_passes = pattern_match( candidate_uri.scheme(), filter_uri.scheme() );
+            if (filter_uri.scheme().empty()) 
+            {
+                filter_uri = LLURI(DEFAULT_URL_PREFIX + filter);
+            }
+            bool authority_passes = pattern_match( candidate_uri.authority(), filter_uri.authority() );
+            bool path_passes = pattern_match( candidate_uri.escapedPath(), filter_uri.escapedPath() );
+
+            if (scheme_passes && authority_passes && path_passes)
+            {
+                passes = true;
+                break;
+            }
+        }
+    }
+    return passes;
+}
+
+U32 LLMediaEntry::setStringFieldWithLimit( std::string &field, const std::string &value, U32 limit )
+{
+    if ( value.length() > limit ) 
+	{
+        return LSL_STATUS_BOUNDS_ERROR;
+    }
+    else 
+	{
+        field = value;
+        return LSL_STATUS_OK;
+    }
+}
+
+U32 LLMediaEntry::setControls(LLMediaEntry::MediaControls controls)
+{
+    if (controls == STANDARD ||
+        controls == MINI)
+    {
+        mControls = controls;
+        return LSL_STATUS_OK;
+    }
+    return LSL_STATUS_BOUNDS_ERROR;
+}
+
+U32 LLMediaEntry::setPermsInteract( U8 val )
+{
+    mPermsInteract = val & PERM_MASK;
+    return LSL_STATUS_OK;
+}
+
+U32 LLMediaEntry::setPermsControl( U8 val )
+{
+    mPermsControl = val & PERM_MASK;
+    return LSL_STATUS_OK;
+}
+
+U32 LLMediaEntry::setCurrentURL(const std::string& current_url)
+{
+    return setCurrentURLInternal( current_url, true );
+}
+
+U32 LLMediaEntry::setCurrentURLInternal(const std::string& current_url, bool check_whitelist)
+{
+    if ( ! check_whitelist || checkCandidateUrl(current_url)) 
+    {
+        return setStringFieldWithLimit( mCurrentURL, current_url, MAX_URL_LENGTH );
+    }
+    else 
+	{
+        return LSL_STATUS_WHITELIST_FAILED;
+    }
+}
+
+U32 LLMediaEntry::setHomeURL(const std::string& home_url)
+{
+    return setStringFieldWithLimit( mHomeURL, home_url, MAX_URL_LENGTH );
+}
+
+U32 LLMediaEntry::setWidthPixels(U16 width)
+{
+    if (width > MAX_WIDTH_PIXELS) return LSL_STATUS_BOUNDS_ERROR;
+    mWidthPixels = width;
+    return LSL_STATUS_OK; 
+}
+
+U32 LLMediaEntry::setHeightPixels(U16 height)
+{
+    if (height > MAX_HEIGHT_PIXELS) return LSL_STATUS_BOUNDS_ERROR;
+    mHeightPixels = height;
+    return LSL_STATUS_OK; 
+}
+
+const LLUUID &LLMediaEntry::getMediaID() const
+{
+    // Lazily generate media ID
+    if (NULL == mMediaIDp)
+    {
+        mMediaIDp = new LLUUID();
+        mMediaIDp->generate();
+    }
+    return *mMediaIDp;
+}
+

indra/llprimitive/llmodel.cpp

@@ -83,7 +83,6 @@ LLModel::~LLModel()
 bool get_dom_sources(const domInputLocalOffset_Array& inputs, S32& pos_offset, S32& tc_offset, S32& norm_offset, S32 &idx_stride,
 					 domSource* &pos_source, domSource* &tc_source, domSource* &norm_source)
 {
-	
 	idx_stride = 0;
 
 	for (U32 j = 0; j < inputs.getCount(); ++j)
@@ -210,7 +209,6 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
 								n[idx[i+norm_offset]*3+2]));
 		}
 		
-		
 		BOOL found = FALSE;
 			
 		LLVolumeFace::VertexMapData::PointMap::iterator point_iter;
@@ -276,7 +274,6 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
 			face = LLVolumeFace();
 			point_map.clear();
 		}
-
 	}
 
 	if (!verts.empty())
@@ -539,7 +536,6 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
 
 	const domInputLocalOffset_Array& inputs = poly->getInput_array();
 
-
 	S32 v_offset = -1;
 	S32 n_offset = -1;
 	S32 t_offset = -1;
@@ -652,7 +648,6 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
 								t->get(t_idx+1));								
 			}
 						
-			
 			verts.push_back(vert);
 		}
 	}
@@ -1467,7 +1462,6 @@ LLSD LLModel::writeModel(
 					}
 				}
 
-
 				LLVector2 tc_range = max_tc - min_tc;
 
 				for (U32 j = 0; j < (U32)face.mNumVertices; ++j)
@@ -1983,6 +1977,7 @@ bool LLModel::matchMaterialOrder(LLModel* ref, int& refFaceCnt, int& modelFaceCn
 	
 	//build a map of material slot names to face indexes
 	bool reorder = false;
+
 	std::set<std::string> base_mat;
 	std::set<std::string> cur_mat;
 

indra/llrender/llgl.cpp

@@ -435,11 +435,7 @@ LLGLManager::LLGLManager() :
 	mHasPointParameters(FALSE),
 	mHasDrawBuffers(FALSE),
 	mHasTextureRectangle(FALSE),
-	mHasTextureMultisample(FALSE),
 	mHasTransformFeedback(FALSE),
-	mMaxSampleMaskWords(0),
-	mMaxColorTextureSamples(0),
-	mMaxDepthTextureSamples(0),
 	mMaxIntegerSamples(0),
 
 	mHasAnisotropic(FALSE),
@@ -732,12 +728,10 @@ bool LLGLManager::initGL()
 	
 	stop_glerror();
 
-	if (mHasTextureMultisample)
+	if (mHasFramebufferMultisample)
 	{
-		glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &mMaxColorTextureSamples);
-		glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &mMaxDepthTextureSamples);
 		glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &mMaxIntegerSamples);
-		glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
+		glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
 	}
 
 	stop_glerror();
@@ -749,24 +743,12 @@ bool LLGLManager::initGL()
 	}
 #endif
 	stop_glerror();
-	mHasTextureMultisample = FALSE;
-#if LL_WINDOWS
-	if (mIsATI)
-	{ //using multisample textures on ATI results in black screen for some reason
-		mHasTextureMultisample = FALSE;
-	}
-#endif
 
 	if (mIsIntel && mGLVersion <= 3.f)
 	{ //never try to use framebuffer objects on older intel drivers (crashy)
 		mHasFramebufferObject = FALSE;
 	}
 
-	if (mHasFramebufferObject)
-	{
-		glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
-	}
-
 	stop_glerror();
 	
 	setToDebugGPU();
@@ -847,14 +829,6 @@ std::string LLGLManager::getRawGLString()
 	return gl_string;
 }
 
-U32 LLGLManager::getNumFBOFSAASamples(U32 samples)
-{
-	samples = llmin(samples, (U32) mMaxColorTextureSamples);
-	samples = llmin(samples, (U32) mMaxDepthTextureSamples);
-	samples = llmin(samples, (U32) 4);
-	return samples;
-}
-
 void LLGLManager::shutdownGL()
 {
 	if (mInited)
@@ -960,7 +934,6 @@ void LLGLManager::initExtensions()
 	mHasDrawBuffers = ExtensionExists("GL_ARB_draw_buffers", gGLHExts.mSysExts);
 	mHasBlendFuncSeparate = ExtensionExists("GL_EXT_blend_func_separate", gGLHExts.mSysExts);
 	mHasTextureRectangle = ExtensionExists("GL_ARB_texture_rectangle", gGLHExts.mSysExts);
-	mHasTextureMultisample = ExtensionExists("GL_ARB_texture_multisample", gGLHExts.mSysExts);
 	mHasDebugOutput = ExtensionExists("GL_ARB_debug_output", gGLHExts.mSysExts);
 	mHasTransformFeedback = mGLVersion >= 4.f ? TRUE : FALSE;
 #if !LL_DARWIN
@@ -1198,13 +1171,6 @@ void LLGLManager::initExtensions()
 	{
 		glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBlendFuncSeparateEXT");
 	}
-	if (mHasTextureMultisample)
-	{
-		glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) GLH_EXT_GET_PROC_ADDRESS("glTexImage2DMultisample");
-		glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) GLH_EXT_GET_PROC_ADDRESS("glTexImage3DMultisample");
-		glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) GLH_EXT_GET_PROC_ADDRESS("glGetMultisamplefv");
-		glSampleMaski = (PFNGLSAMPLEMASKIPROC) GLH_EXT_GET_PROC_ADDRESS("glSampleMaski");
-	}
 	if (mHasTransformFeedback)
 	{
 		glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC) GLH_EXT_GET_PROC_ADDRESS("glBeginTransformFeedback");

indra/llrender/llgl.h

@@ -104,11 +104,7 @@ public:
 	BOOL mHasDrawBuffers;
 	BOOL mHasDepthClamp;
 	BOOL mHasTextureRectangle;
-	BOOL mHasTextureMultisample;
 	BOOL mHasTransformFeedback;
-	S32 mMaxSampleMaskWords;
-	S32 mMaxColorTextureSamples;
-	S32 mMaxDepthTextureSamples;
 	S32 mMaxIntegerSamples;
 
 	// Other extensions.
@@ -155,7 +151,6 @@ public:
 	void printGLInfoString();
 	void getGLInfo(LLSD& info);
 
-	U32 getNumFBOFSAASamples(U32 desired_samples = 32);
 	// In ALL CAPS
 	std::string mGLVendor;
 	std::string mGLVendorShort;
@@ -521,4 +516,5 @@ extern BOOL gGLActive;
 #ifndef GL_DEPTH24_STENCIL8
 #define GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_EXT
 #endif 
+
 #endif // LL_LLGL_H

indra/llrender/llglheaders.h

@@ -783,6 +783,7 @@ extern PFNGLDEBUGMESSAGECONTROLARBPROC glDebugMessageControlARB;
 extern PFNGLDEBUGMESSAGEINSERTARBPROC glDebugMessageInsertARB;
 extern PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARB;
 extern PFNGLGETDEBUGMESSAGELOGARBPROC glGetDebugMessageLogARB;
+
 #elif LL_DARWIN
 //----------------------------------------------------------------------------
 // LL_DARWIN
@@ -825,6 +826,7 @@ extern void glGenerateMipmapEXT(GLenum target) AVAILABLE_MAC_OS_X_VERSION_10_4_A
 #define glGenerateMipmap glGenerateMipmapEXT
 #define GL_MAX_SAMPLES	0x8D57
 #endif
+
 // GL_ARB_draw_buffers
 extern void glDrawBuffersARB(GLsizei n, const GLenum* bufs) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
 
@@ -997,7 +999,7 @@ extern void glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
 }
 #endif
 
-#include <AGL/gl.h>
+#include <OpenGL/gl.h>
 
 #endif // LL_MESA / LL_WINDOWS / LL_DARWIN
 
@@ -1029,4 +1031,5 @@ extern void glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
 #define GL_TEXTURE_FREE_MEMORY_ATI                 0x87FC
 #define GL_RENDERBUFFER_FREE_MEMORY_ATI            0x87FD
 #endif
+
 #endif // LL_LLGLHEADERS_H

indra/llrender/llimagegl.cpp

@@ -330,7 +330,6 @@ S32 LLImageGL::updateBoundTexMem(const S32 mem, const S32 ncomponents, S32 categ
 //static 
 void LLImageGL::destroyGL(BOOL save_state)
 {
-	deleteDeadTextures(); //Dump unimportant textures.
 	for (S32 stage = 0; stage < gGLManager.mNumTextureUnits; stage++)
 	{
 		gGL.getTexUnit(stage)->unbind(LLTexUnit::TT_TEXTURE);
@@ -364,7 +363,6 @@ void LLImageGL::destroyGL(BOOL save_state)
 	}
 	llinfos << "Storing " << stored_count << " images..." << llendl;
 	sAllowReadBackRaw = false ;
-	deleteDeadTextures();//Now, actually call glDeleteTextures for everything.
 }
 
 //static 
@@ -1528,7 +1526,7 @@ void LLImageGL::deleteDeadTextures()
 {
 	bool reset = false;
 
-	for(U32 i=0;i<LLTexUnit::TT_NONE;++i)
+	/*for(U32 i=0;i<LLTexUnit::TT_NONE;++i)
 	{
 		for(dead_texturelist_t::iterator it=sDeadTextureList[i].begin();it!=sDeadTextureList[i].end();++it)
 		{
@@ -1554,7 +1552,7 @@ void LLImageGL::deleteDeadTextures()
 				stop_glerror();
 			}
 		}
-	}
+	}*/
 
 	if (reset)
 	{

indra/llrender/llrendertarget.cpp

@@ -699,6 +699,28 @@ bool LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth
 	release();
 	stop_glerror();
 
+	if (!gGLManager.mHasFramebufferMultisample || !gGLManager.mHasFramebufferObject || !(sUseFBO || use_fbo))
+		return false;
+
+	if(color_fmt != GL_RGBA)
+	{
+		llwarns << "Unsupported color format: " << color_fmt << llendl;
+		return false;
+	}
+
+	//Restrict to valid sample count
+	{
+		mSamples = samples;
+		mSamples = llmin(mSamples, (U32)4);	//Cap to prevent memory bloat.
+		mSamples = llmin(mSamples, (U32) gGLManager.mMaxIntegerSamples);//GL_RGBA
+
+		if(depth && !stencil)
+			mSamples = llmin(mSamples, (U32) gGLManager.mMaxSamples);	//GL_DEPTH_COMPONENT16_ARB
+	}
+
+	if (mSamples <= 1)
+		return false;
+	
 	mResX = resx;
 	mResY = resy;
 
@@ -706,30 +728,16 @@ bool LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth
 	mUseDepth = depth;
 	mStencil = stencil;
 
-	if (!gGLManager.mHasFramebufferMultisample)
-	{
-		llerrs << "Attempting to allocate unsupported render target type!" << llendl;
-		return false;
-	}
-
-	mSamples = gGLManager.getNumFBOFSAASamples(samples);
-	
-	if (mSamples <= 1)
-	{
-		llerrs << "Cannot create a multisample buffer with less than 2 samples." << llendl;
-		return false;
-	}
-
-	stop_glerror();
-
-	if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
 	{
 
 		if (depth)
 		{
 			stop_glerror();
 			if(!allocateDepth())
+			{
+				release();
 				return false;
+			}
 			stop_glerror();
 		}
 		glGenFramebuffers(1, (GLuint *) &mFBO);
@@ -779,6 +787,7 @@ bool LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
 	if (glGetError() != GL_NO_ERROR)
 	{
 		llwarns << "Unable to allocate color buffer for multisample render target." << llendl;
+		release();
 		return false;
 	}
 	

indra/llrender/llshadermgr.cpp

@@ -231,7 +231,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 	if (features->hasLighting)
 	{
-	
 		if (features->hasWaterFog)
 		{
 			if (features->disableTextureIndex)

indra/llui/CMakeLists.txt

@@ -12,7 +12,6 @@ include(LLRender)
 include(LLWindow)
 include(LLVFS)
 include(LLXML)
-include(LLXUIXML)
 
 include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
@@ -24,7 +23,6 @@ include_directories(
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLVFS_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
-    ${LLXUIXML_INCLUDE_DIRS}
     )
 
 set(llui_SOURCE_FILES
@@ -73,6 +71,7 @@ set(llui_SOURCE_FILES
     lltextparser.cpp
     lltrans.cpp
     llui.cpp
+    lluicolor.cpp
     lluictrl.cpp
     lluictrlfactory.cpp
     lluiimage.cpp
@@ -142,6 +141,7 @@ set(llui_HEADER_FILES
     lluictrl.h
     lluifwd.h
     llui.h
+    lluicolor.h
     lluiimage.h
     lluistring.h
     lluixmltags.h
@@ -165,7 +165,6 @@ target_link_libraries(llui
     llwindow
     llimage
     llvfs       # ugh, just for LLDir
-    llxuixml
     llxml
     llcommon    # must be after llimage, llwindow, llrender
     llmath

indra/llwindow/llmousehandler.h

@@ -45,17 +45,20 @@ class LLMouseHandler
 public:
 	LLMouseHandler() {}
 	virtual ~LLMouseHandler() {}
+
 	typedef enum {
 		SHOW_NEVER,
 		SHOW_IF_NOT_BLOCKED,
 		SHOW_ALWAYS,
 	} EShowToolTip;
+
 	typedef enum {
 		CLICK_LEFT,
 		CLICK_MIDDLE,
 		CLICK_RIGHT,
 		CLICK_DOUBLELEFT
 	} EClickType;
+
 	virtual BOOL	handleAnyMouseClick(S32 x, S32 y, MASK mask, EClickType clicktype, BOOL down);
 	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask) = 0;
 	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask) = 0;

indra/llwindow/llwindow.cpp

@@ -113,6 +113,7 @@ LLWindow::LLWindow(LLWindowCallbacks* callbacks, BOOL fullscreen, U32 flags)
 	  mSupportedResolutions(NULL),
 	  mNumSupportedResolutions(0),
 	  mCurrentCursor(UI_CURSOR_ARROW),
+	  mNextCursor(UI_CURSOR_ARROW),
 	  mCursorHidden(FALSE),
 	  mBusyCount(0),
 	  mIsMouseClipping(FALSE),
@@ -125,7 +126,6 @@ LLWindow::LLWindow(LLWindowCallbacks* callbacks, BOOL fullscreen, U32 flags)
 
 LLWindow::~LLWindow()
 {
-
 }
 
 //virtual
@@ -139,6 +139,7 @@ BOOL LLWindow::canDelete()
 {
 	return TRUE;
 }
+
 // virtual
 void LLWindow::incBusyCount()
 {

indra/llwindow/llwindow.h

@@ -104,12 +104,14 @@ public:
 	virtual S32 getBusyCount() const;
 
 	// Sets cursor, may set to arrow+hourglass
-	virtual void setCursor(ECursorType cursor) = 0;
+	virtual void setCursor(ECursorType cursor) { mNextCursor = cursor; };
 	virtual ECursorType getCursor() const;
+	virtual void updateCursor() = 0;
 
 	virtual void captureMouse() = 0;
 	virtual void releaseMouse() = 0;
 	virtual void setMouseClipping( BOOL b ) = 0;
+
 	virtual BOOL isClipboardTextAvailable() = 0;
 	virtual BOOL pasteTextFromClipboard(LLWString &dst) = 0;
 	virtual BOOL copyTextToClipboard(const LLWString &src) = 0;
@@ -196,6 +198,7 @@ protected:
 	LLWindowResolution* mSupportedResolutions;
 	S32			mNumSupportedResolutions;
 	ECursorType	mCurrentCursor;
+	ECursorType	mNextCursor;
 	BOOL		mCursorHidden;
 	S32			mBusyCount;	// how deep is the "cursor busy" stack?
 	BOOL		mIsMouseClipping;  // Is this window currently clipping the mouse

indra/llwindow/llwindowcallbacks.h

@@ -91,5 +91,4 @@ public:
 };
 
 
-
 #endif

indra/llwindow/llwindowheadless.h

@@ -61,7 +61,7 @@ public:
 	/*virtual*/ void showCursorFromMouseMove() {};
 	/*virtual*/ void hideCursorUntilMouseMove() {};
 	/*virtual*/ BOOL isCursorHidden() {return FALSE;};
-	/*virtual*/ void setCursor(ECursorType cursor) {};
+	/*virtual*/ void updateCursor() {};
 	//virtual ECursorType getCursor() { return mCurrentCursor; };
 	/*virtual*/ void captureMouse() {};
 	/*virtual*/ void releaseMouse() {};

indra/llwindow/llwindowmacosx-objc.mm

@@ -50,6 +50,11 @@ void setupCocoa()
 	{
 		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 		
+		// The following prevents the Cocoa command line parser from trying to open 'unknown' arguements as documents.
+		// ie. running './secondlife -set Language fr' would cause a pop-up saying can't open document 'fr' 
+		// when init'ing the Cocoa App window.		
+		[[NSUserDefaults standardUserDefaults] setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
+		
 		// This is a bit of voodoo taken from the Apple sample code "CarbonCocoa_PictureCursor":
 		//   http://developer.apple.com/samplecode/CarbonCocoa_PictureCursor/index.html
 		
@@ -60,6 +65,8 @@ void setupCocoa()
 		[[[NSWindow alloc] init] release];
 
 		[pool release];
+		
+		inited = true;
 	}
 }
 

indra/llwindow/llwindowmacosx.cpp

@@ -484,7 +484,6 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 			true,
 			(long)this);
 
-
 		if (!mWindow)
 		{
 			setupFailure("Window creation error", "Error", OSMB_OK);
@@ -1042,6 +1041,7 @@ void LLWindowMacOSX::hide()
 	HideWindow(mWindow);
 }
 
+//virtual
 void LLWindowMacOSX::minimize()
 {
 	setMouseClipping(FALSE);
@@ -1049,6 +1049,7 @@ void LLWindowMacOSX::minimize()
 	CollapseWindow(mWindow, true);
 }
 
+//virtual
 void LLWindowMacOSX::restore()
 {
 	show();
@@ -1169,6 +1170,8 @@ void LLWindowMacOSX::gatherInput()
 
 		}
 	}
+	
+	updateCursor();
 }
 
 BOOL LLWindowMacOSX::getPosition(LLCoordScreen *position)
@@ -1441,7 +1444,7 @@ static void fixOrigin(void)
 	::GetPortBounds(port, &portrect);
 	if((portrect.left != 0) || (portrect.top != 0))
 	{
-		// Mozilla sometimes changes our port origin.  Fuckers.
+		// Mozilla sometimes changes our port origin.
 		::SetOrigin(0,0);
 	}
 }
@@ -2133,6 +2136,7 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
 				{
 					UInt32 modifiers = 0;
 
+
 					// First, process the raw event.
 					{
 						EventRef rawEvent = NULL;
@@ -2843,7 +2847,7 @@ static void initPixmapCursor(int cursorid, int hotspotX, int hotspotY)
 	gCursors[cursorid] = createImageCursor(fullpath.c_str(), hotspotX, hotspotY);
 }
 
-void LLWindowMacOSX::setCursor(ECursorType cursor)
+void LLWindowMacOSX::updateCursor()
 {
 	OSStatus result = noErr;
 
@@ -2851,30 +2855,30 @@ void LLWindowMacOSX::setCursor(ECursorType cursor)
 	{
 		// A drag is in progress...remember the requested cursor and we'll
 		// restore it when it is done
-		mCurrentCursor = cursor;
+		mCurrentCursor = mNextCursor;
 		return;
 	}
 		
-	if (cursor == UI_CURSOR_ARROW
+	if (mNextCursor == UI_CURSOR_ARROW
 		&& mBusyCount > 0)
 	{
-		cursor = UI_CURSOR_WORKING;
+		mNextCursor = UI_CURSOR_WORKING;
 	}
 	
-	if(mCurrentCursor == cursor)
+	if(mCurrentCursor == mNextCursor)
 		return;
 
 	// RN: replace multi-drag cursors with single versions
-	if (cursor == UI_CURSOR_ARROWDRAGMULTI)
+	if (mNextCursor == UI_CURSOR_ARROWDRAGMULTI)
 	{
-		cursor = UI_CURSOR_ARROWDRAG;
+		mNextCursor = UI_CURSOR_ARROWDRAG;
 	}
-	else if (cursor == UI_CURSOR_ARROWCOPYMULTI)
+	else if (mNextCursor == UI_CURSOR_ARROWCOPYMULTI)
 	{
-		cursor = UI_CURSOR_ARROWCOPY;
+		mNextCursor = UI_CURSOR_ARROWCOPY;
 	}
 
-	switch(cursor)
+	switch(mNextCursor)
 	{
 	default:
 	case UI_CURSOR_ARROW:
@@ -2926,7 +2930,7 @@ void LLWindowMacOSX::setCursor(ECursorType cursor)
 	case UI_CURSOR_TOOLBUY:
 	case UI_CURSOR_TOOLOPEN:
 	case UI_CURSOR_TOOLPAY:
-		result = setImageCursor(gCursors[cursor]);
+		result = setImageCursor(gCursors[mNextCursor]);
 		break;
 
 	}
@@ -2936,7 +2940,7 @@ void LLWindowMacOSX::setCursor(ECursorType cursor)
 		InitCursor();
 	}
 
-	mCurrentCursor = cursor;
+	mCurrentCursor = mNextCursor;
 }
 
 ECursorType LLWindowMacOSX::getCursor() const
@@ -2967,9 +2971,9 @@ void LLWindowMacOSX::initCursors()
 	initPixmapCursor(UI_CURSOR_TOOLPLAY, 1, 1);
 	initPixmapCursor(UI_CURSOR_TOOLPAUSE, 1, 1);
 	initPixmapCursor(UI_CURSOR_TOOLMEDIAOPEN, 1, 1);
-	initPixmapCursor(UI_CURSOR_TOOLSIT, 1, 1);
+	initPixmapCursor(UI_CURSOR_TOOLSIT, 20, 15);
-	initPixmapCursor(UI_CURSOR_TOOLBUY, 1, 1);
+	initPixmapCursor(UI_CURSOR_TOOLBUY, 20, 15);
-	initPixmapCursor(UI_CURSOR_TOOLOPEN, 1, 1);
+	initPixmapCursor(UI_CURSOR_TOOLOPEN, 20, 15);
 	initPixmapCursor(UI_CURSOR_TOOLPAY, 1, 1);
 
 	initPixmapCursor(UI_CURSOR_SIZENWSE, 10, 10);

indra/llwindow/llwindowmacosx.h

@@ -73,7 +73,7 @@ public:
 	/*virtual*/ void showCursorFromMouseMove();
 	/*virtual*/ void hideCursorUntilMouseMove();
 	/*virtual*/ BOOL isCursorHidden();
-	/*virtual*/ void setCursor(ECursorType cursor);
+	/*virtual*/ void updateCursor();
 	/*virtual*/ ECursorType getCursor() const;
 	/*virtual*/ void captureMouse();
 	/*virtual*/ void releaseMouse();

indra/llwindow/llwindowmesaheadless.h

@@ -65,7 +65,7 @@ public:
 	/*virtual*/ void showCursorFromMouseMove() {};
 	/*virtual*/ void hideCursorUntilMouseMove() {};
 	/*virtual*/ BOOL isCursorHidden() {return FALSE;};
-	/*virtual*/ void setCursor(ECursorType cursor) {};
+	/*virtual*/ void updateCursor() {};
 	//virtual ECursorType getCursor() { return mCurrentCursor; };
 	/*virtual*/ void captureMouse() {};
 	/*virtual*/ void releaseMouse() {};

indra/llwindow/llwindowsdl.cpp

@@ -39,6 +39,7 @@
 
 #include "llwindowcallbacks.h"
 #include "llkeyboardsdl.h"
+
 #include "llerror.h"
 #include "llgl.h"
 #include "llstring.h"
@@ -221,15 +222,14 @@ LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks,
 #endif // LL_X11
 
 #if LL_GTK
-	// We MUST be the first to initialize GTK, i.e. we have to beat
+	// We MUST be the first to initialize GTK so that GTK doesn't get badly
-	// our embedded Mozilla to the punch so that GTK doesn't get badly
 	// initialized with a non-C locale and cause lots of serious random
 	// weirdness.
 	ll_try_gtk_init();
 #endif // LL_GTK
 
-	// Get the original aspect ratio of the main device.
+	// Assume 4:3 aspect ratio until we know better
-	mOriginalAspectRatio = 1024.0 / 768.0;  // !!! *FIX: ? //(double)CGDisplayPixelsWide(mDisplay) / (double)CGDisplayPixelsHigh(mDisplay);
+	mOriginalAspectRatio = 1024.0 / 768.0;
 
 	if (title.empty())
 		mWindowTitle = "SDL Window";  // *FIX: (???)
@@ -425,7 +425,6 @@ static int x11_detect_VRAM_kb()
 BOOL LLWindowSDL::createContext(int x, int y, int width, int height, int bits, BOOL fullscreen, BOOL disable_vsync)
 {
 	//bool			glneedsinit = false;
-//    const char *gllibname = null;
 
 	llinfos << "createContext, fullscreen=" << fullscreen <<
 	    " size=" << width << "x" << height << llendl;
@@ -856,11 +855,13 @@ void LLWindowSDL::hide()
     // *FIX: What to do with SDL?
 }
 
+//virtual
 void LLWindowSDL::minimize()
 {
     // *FIX: What to do with SDL?
 }
 
+//virtual
 void LLWindowSDL::restore()
 {
     // *FIX: What to do with SDL?
@@ -1680,12 +1681,13 @@ void check_vm_bloat()
 	}
 #endif // LL_LINUX
 }
+
+
 // virtual
 void LLWindowSDL::processMiscNativeEvents()
 {
 #if LL_GTK
 	// Pump GTK events to avoid starvation for:
-	// * Embedded Gecko
 	// * DBUS servicing
 	// * Anything else which quietly hooks into the default glib/GTK loop
     if (ll_try_gtk_init())
@@ -1747,6 +1749,7 @@ void LLWindowSDL::gatherInput()
 		    mKeyScanCode = event.key.keysym.scancode;
 		    mKeyVirtualKey = event.key.keysym.unicode;
 		    mKeyModifiers = event.key.keysym.mod;
+
 		    gKeyboard->handleKeyDown(event.key.keysym.sym, event.key.keysym.mod);
 		    // part of the fix for SL-13243
 		    if (SDLCheckGrabbyKeys(event.key.keysym.sym, TRUE) != 0)
@@ -1933,6 +1936,8 @@ void LLWindowSDL::gatherInput()
         }
     }
 	
+	updateCursor();
+
 #if LL_X11
     // This is a good time to stop flashing the icon if our mFlashTimer has
     // expired.
@@ -2018,7 +2023,7 @@ static SDL_Cursor *makeSDLCursorFromBMP(const char *filename, int hotx, int hoty
 	return sdlcursor;
 }
 
-void LLWindowSDL::setCursor(ECursorType cursor)
+void LLWindowSDL::updateCursor()
 {
 	if (ATIbug) {
 		// cursor-updating is very flaky when this bug is
@@ -2026,11 +2031,11 @@ void LLWindowSDL::setCursor(ECursorType cursor)
 		return;
 	}
 
-	if (mCurrentCursor != cursor)
+	if (mCurrentCursor != mNextCursor)
 	{
-		if (cursor < UI_CURSOR_COUNT)
+		if (mNextCursor < UI_CURSOR_COUNT)
 		{
-			SDL_Cursor *sdlcursor = mSDLCursors[cursor];
+			SDL_Cursor *sdlcursor = mSDLCursors[mNextCursor];
 			// Try to default to the arrow for any cursors that
 			// did not load correctly.
 			if (!sdlcursor && mSDLCursors[UI_CURSOR_ARROW])
@@ -2038,9 +2043,9 @@ void LLWindowSDL::setCursor(ECursorType cursor)
 			if (sdlcursor)
 				SDL_SetCursor(sdlcursor);
 		} else {
-			llwarns << "Tried to set invalid cursor number " << cursor << llendl;
+			llwarns << "Tried to set invalid cursor number " << mNextCursor << llendl;
 		}
-		mCurrentCursor = cursor;
+		mCurrentCursor = mNextCursor;
 	}
 }
 

indra/llwindow/llwindowsdl.h

@@ -78,7 +78,7 @@ public:
 	/*virtual*/ void showCursorFromMouseMove();
 	/*virtual*/ void hideCursorUntilMouseMove();
 	/*virtual*/ BOOL isCursorHidden();
-	/*virtual*/ void setCursor(ECursorType cursor);
+	/*virtual*/ void updateCursor();
 	/*virtual*/ void captureMouse();
 	/*virtual*/ void releaseMouse();
 	/*virtual*/ void setMouseClipping( BOOL b );

indra/llwindow/llwindowwin32.cpp

@@ -677,6 +677,7 @@ void LLWindowWin32::hide()
 	ShowWindow(mWindowHandle, SW_HIDE);
 }
 
+//virtual
 void LLWindowWin32::minimize()
 {
 	setMouseClipping(FALSE);
@@ -684,7 +685,7 @@ void LLWindowWin32::minimize()
 	ShowWindow(mWindowHandle, SW_MINIMIZE);
 }
 
-
+//virtual
 void LLWindowWin32::restore()
 {
 	ShowWindow(mWindowHandle, SW_RESTORE);
@@ -1019,6 +1020,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 		dw_style = WS_OVERLAPPEDWINDOW;
 	}
 
+
 	// don't post quit messages when destroying old windows
 	mPostQuit = FALSE;
 
@@ -1070,6 +1072,8 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 		return FALSE;
 	}
 
+	LL_INFOS("Window") << "Device context retrieved." << llendl ;
+
 	if (!(pixel_format = ChoosePixelFormat(mhDC, &pfd)))
 	{
 		close();
@@ -1078,6 +1082,8 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 		return FALSE;
 	}
 
+	LL_INFOS("Window") << "Pixel format chosen." << llendl ;
+
 	// Verify what pixel format we actually received.
 	if (!DescribePixelFormat(mhDC, pixel_format, sizeof(PIXELFORMATDESCRIPTOR),
 		&pfd))
@@ -1673,18 +1679,18 @@ void LLWindowWin32::initCursors()
 
 
 
-void LLWindowWin32::setCursor(ECursorType cursor)
+void LLWindowWin32::updateCursor()
 {
-	if (cursor == UI_CURSOR_ARROW
+	if (mNextCursor == UI_CURSOR_ARROW
 		&& mBusyCount > 0)
 	{
-		cursor = UI_CURSOR_WORKING;
+		mNextCursor = UI_CURSOR_WORKING;
 	}
 
-	if( mCurrentCursor != cursor )
+	if( mCurrentCursor != mNextCursor )
 	{
-		mCurrentCursor = cursor;
+		mCurrentCursor = mNextCursor;
-		SetCursor( mCursor[cursor] );
+		SetCursor( mCursor[mNextCursor] );
 	}
 }
 
@@ -1764,6 +1770,8 @@ void LLWindowWin32::gatherInput()
 
 	mInputProcessingPaused = FALSE;
 
+	updateCursor();
+
 	// clear this once we've processed all mouse messages that might have occurred after
 	// we slammed the mouse position
 	mMousePositionModified = FALSE;

indra/llwindow/llwindowwin32.h

@@ -72,7 +72,7 @@ public:
 	/*virtual*/ void showCursorFromMouseMove();
 	/*virtual*/ void hideCursorUntilMouseMove();
 	/*virtual*/ BOOL isCursorHidden();
-	/*virtual*/ void setCursor(ECursorType cursor);
+	/*virtual*/ void updateCursor();
 	/*virtual*/ ECursorType getCursor() const;
 	/*virtual*/ void captureMouse();
 	/*virtual*/ void releaseMouse();

indra/llxuixml/CMakeLists.txt

@@ -1,40 +0,0 @@
-# -*- cmake -*-
-
-project(llxuixml)
-
-include(00-Common)
-include(LLCommon)
-include(LLMath)
-include(LLXML)
-
-include_directories(
-    ${LLCOMMON_INCLUDE_DIRS}
-    ${LLMATH_INCLUDE_DIRS}
-    ${LLXML_INCLUDE_DIRS}
-    )
-
-set(llxuixml_SOURCE_FILES
-    llinitparam.cpp
-    lluicolor.cpp
-    )
-    
-set(llxuixml_HEADER_FILES
-    CMakeLists.txt
-
-    llinitparam.h
-    lluicolor.h
-    )
-
-set_source_files_properties(${llxuixml_HEADER_FILES}
-                            PROPERTIES HEADER_FILE_ONLY TRUE)
-
-list(APPEND llxuixml_SOURCE_FILES ${llxuixml_HEADER_FILES})
-
-add_library (llxuixml ${llxuixml_SOURCE_FILES})
-# Libraries on which this library depends, needed for Linux builds
-# Sort by high-level to low-level
-target_link_libraries(llxuixml
-    llxml
-    llcommon
-    llmath
-    )

indra/newview/CMakeLists.txt

@@ -37,7 +37,6 @@ include(LLUI)
 include(LLVFS)
 include(LLWindow)
 include(LLXML)
-include(LLXUIXML)
 include(LScript)
 include(Linking)
 include(NDOF)
@@ -72,7 +71,6 @@ include_directories(
     ${LLVFS_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
-    ${LLXUIXML_INCLUDE_DIRS}
     ${LSCRIPT_INCLUDE_DIRS}
     ${LSCRIPT_INCLUDE_DIRS}/lscript_compile
     )
@@ -98,11 +96,7 @@ set(viewer_SOURCE_FILES
     ascentprefschat.cpp
     ascentprefssys.cpp
     ascentprefsvan.cpp
-	#dhparam.cpp
-	#dsaparam.cpp
     emeraldboobutils.cpp
-    dofloaterhex.cpp
-    dohexeditor.cpp
     floatersculptpreview.cpp
     hbfloatergrouptitles.cpp
     hgfloatertexteditor.cpp
@@ -115,6 +109,7 @@ set(viewer_SOURCE_FILES
     jcfloaterareasearch.cpp
     chatbar_as_cmdline.cpp
     qtoolalign.cpp
+	NACLantispam.cpp
     llaccountingcostmanager.cpp
     llagent.cpp
     llagentaccess.cpp
@@ -474,8 +469,6 @@ set(viewer_SOURCE_FILES
     llviewerfoldertype.cpp
     llviewergenericmessage.cpp
     llviewergesture.cpp
-    #llviewerimage.cpp
-    #llviewerimagelist.cpp
     llviewerinventory.cpp
     llviewerjoint.cpp
     llviewerjointattachment.cpp
@@ -528,7 +521,6 @@ set(viewer_SOURCE_FILES
     llvopartgroup.cpp
     llvosky.cpp
     llvosurfacepatch.cpp
-    llvotextbubble.cpp
     llvotree.cpp
     llvovolume.cpp
     llvowater.cpp
@@ -576,6 +568,7 @@ set(viewer_HEADER_FILES
     CMakeLists.txt
     ViewerInstall.cmake
 
+	NACLantispam.h
     sgmemstat.h
     sgversion.h
     llviewerobjectbackup.h
@@ -595,8 +588,6 @@ set(viewer_HEADER_FILES
     ascentprefssys.h
     ascentprefsvan.h
     emeraldboobutils.h
-    dofloaterhex.h
-    dohexeditor.h
     floatersculptpreview.h
     hbfloatergrouptitles.h
     hgfloatertexteditor.h
@@ -976,8 +967,6 @@ set(viewer_HEADER_FILES
     llviewerfoldertype.h
     llviewergenericmessage.h
     llviewergesture.h
-    #llviewerimage.h
-    #llviewerimagelist.h
     llviewerinventory.h
     llviewerjoint.h
     llviewerjointattachment.h
@@ -1030,7 +1019,6 @@ set(viewer_HEADER_FILES
     llvopartgroup.h
     llvosky.h
     llvosurfacepatch.h
-    llvotextbubble.h
     llvotree.h
     llvotreenew.h
     llvovolume.h
@@ -1372,6 +1360,7 @@ if (FMOD OR FMODEX)
   endif (FMOD)
 
   if (DARWIN)
+    if(FMOD)
       set(fmodwrapper_SOURCE_FILES fmodwrapper.cpp)
       add_library(fmodwrapper SHARED ${fmodwrapper_SOURCE_FILES})
       if (FMODEX)
@@ -1389,6 +1378,10 @@ if (FMOD OR FMODEX)
         )
       set(FMODWRAPPER_LIBRARY fmodwrapper)
       target_link_libraries(fmodwrapper ${fmodwrapper_needed_LIBRARIES})
+    endif(FMOD)
+    if(FMODEX)
+      set(FMODWRAPPER_LIBRARY ${FMODEX_LIBRARY})
+    endif(FMODEX)
   else (DARWIN)
     # fmodwrapper unnecessary on linux or windows, for fmod and fmodex
     if (FMODEX)
@@ -1547,7 +1540,6 @@ target_link_libraries(${VIEWER_BINARY_NAME}
     ${LLVFS_LIBRARIES}
     ${LLWINDOW_LIBRARIES}
     ${LLXML_LIBRARIES}
-    ${LLXUIXML_LIBRARIES}
     ${LSCRIPT_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
@@ -1798,7 +1790,7 @@ endif (WINDOWS)
 if (DARWIN)
 # Don't do this here -- it's taken care of by viewer_manifest.py
 #  add_custom_command(TARGET ${VIEWER_BINARY_NAME} POST_BUILD
-#    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib_release/libllqtwebkit.dylib ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/llplugin/
+#    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib/release/libllqtwebkit.dylib ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/llplugin/
-#    DEPENDS ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib_release/libllqtwebkit.dylib
+#    DEPENDS ${CMAKE_SOURCE_DIR}/../libraries/universal-darwin/lib/release/libllqtwebkit.dylib
 #  )
 endif (DARWIN)

indra/newview/English.lproj/InfoPlist.strings

@@ -2,6 +2,6 @@
 
 CFBundleName = "Singularity";
 
-CFBundleShortVersionString = "Singularity Viewer 1.5.0.0";
+CFBundleShortVersionString = "Singularity Viewer 1.7.0.0";
-CFBundleGetInfoString = "Singularity Viewer 1.5.0.0, Copyright 2010 Siana Gearz";
+CFBundleGetInfoString = "Singularity Viewer 1.7.0.0, Copyright 2012 Siana Gearz";
 

indra/newview/Info-Singularity.plist

@@ -9,7 +9,7 @@
 	<key>CFBundleIconFile</key>
 	<string>singularity.icns</string>
 	<key>CFBundleIdentifier</key>
-	<string>com.secondlife.indra.viewer</string>
+	<string>org.singularityviewer.singularity</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>

indra/newview/NACLantispam.cpp

@@ -0,0 +1,406 @@
+#include "llviewerprecompiledheaders.h"
+#include "NACLantispam.h"
+#include "llviewercontrol.h"
+#include "llnotificationsutil.h"
+#include "llviewerobjectlist.h"
+#include "llagent.h"
+#include <time.h>
+
+U32 NACLAntiSpamRegistry::globalAmount;
+U32 NACLAntiSpamRegistry::globalTime;
+bool NACLAntiSpamRegistry::bGlobalQueue;
+NACLAntiSpamQueue* NACLAntiSpamRegistry::queues[NACLAntiSpamRegistry::QUEUE_MAX] = {0};
+std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*> NACLAntiSpamRegistry::globalEntries;
+std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*>::iterator NACLAntiSpamRegistry::it2;
+
+const std::string COLLISION_SOUNDS[] ={"dce5fdd4-afe4-4ea1-822f-dd52cac46b08","51011582-fbca-4580-ae9e-1a5593f094ec","68d62208-e257-4d0c-bbe2-20c9ea9760bb","75872e8c-bc39-451b-9b0b-042d7ba36cba","6a45ba0b-5775-4ea8-8513-26008a17f873","992a6d1b-8c77-40e0-9495-4098ce539694","2de4da5a-faf8-46be-bac6-c4d74f1e5767","6e3fb0f7-6d9c-42ca-b86b-1122ff562d7d","14209133-4961-4acc-9649-53fc38ee1667","bc4a4348-cfcc-4e5e-908e-8a52a8915fe6","9e5c1297-6eed-40c0-825a-d9bcd86e3193","e534761c-1894-4b61-b20c-658a6fb68157","8761f73f-6cf9-4186-8aaa-0948ed002db1","874a26fd-142f-4173-8c5b-890cd846c74d","0e24a717-b97e-4b77-9c94-b59a5a88b2da","75cf3ade-9a5b-4c4d-bb35-f9799bda7fb2","153c8bf7-fb89-4d89-b263-47e58b1b4774","55c3e0ce-275a-46fa-82ff-e0465f5e8703","24babf58-7156-4841-9a3f-761bdbb8e237","aca261d8-e145-4610-9e20-9eff990f2c12","0642fba6-5dcf-4d62-8e7b-94dbb529d117","25a863e8-dc42-4e8a-a357-e76422ace9b5","9538f37c-456e-4047-81be-6435045608d4","8c0f84c3-9afd-4396-b5f5-9bca2c911c20","be582e5d-b123-41a2-a150-454c39e961c8","c70141d4-ba06-41ea-bcbc-35ea81cb8335","7d1826f4-24c4-4aac-8c2e-eff45df37783","063c97d3-033a-4e9b-98d8-05c8074922cb","00000000-0000-0000-0000-000000000120"};
+const int COLLISION_SOUNDS_SIZE=29;
+
+// NaClAntiSpamQueueEntry
+
+NACLAntiSpamQueueEntry::NACLAntiSpamQueueEntry()
+{
+	entryTime=0;
+	entryAmount=0;
+	blocked=false;
+}
+void NACLAntiSpamQueueEntry::clearEntry()
+{
+	entryTime=0;
+	entryAmount=0;
+	blocked=false;
+}
+U32 NACLAntiSpamQueueEntry::getEntryAmount()
+{
+	return entryAmount;
+}
+U32 NACLAntiSpamQueueEntry::getEntryTime()
+{
+	return entryTime;
+}
+void NACLAntiSpamQueueEntry::updateEntryAmount()
+{
+	entryAmount++;
+}
+void NACLAntiSpamQueueEntry::updateEntryTime()
+{
+	entryTime=time(0);
+}
+void NACLAntiSpamQueueEntry::setBlocked()
+{
+	blocked=true;
+}
+bool NACLAntiSpamQueueEntry::getBlocked()
+{
+	return blocked;
+}
+
+// NaClAntiSpamQueue
+
+NACLAntiSpamQueue::NACLAntiSpamQueue(U32 time, U32 amount)
+{
+	queueTime=time;
+	queueAmount=amount;
+}
+void NACLAntiSpamQueue::setAmount(U32 amount)
+{
+	queueAmount=amount;
+}
+void NACLAntiSpamQueue::setTime(U32 time)
+{
+	queueTime=time;
+}
+void NACLAntiSpamQueue::clearEntries()
+{
+	for(it = entries.begin(); it != entries.end(); it++)
+	{
+		it->second->clearEntry();
+	}
+}
+void NACLAntiSpamQueue::purgeEntries()
+{
+	for(it = entries.begin(); it != entries.end(); it++)
+	{
+		delete it->second;
+	}
+	entries.clear();
+}
+void NACLAntiSpamQueue::blockEntry(LLUUID& source)
+{
+	it=entries.find(source.asString());
+	if(it == entries.end())
+	{
+		entries[source.asString()]=new NACLAntiSpamQueueEntry();
+	}
+	entries[source.asString()]->setBlocked();
+}
+int NACLAntiSpamQueue::checkEntry(LLUUID& name, U32 multiplier)
+{
+	it=entries.find(name.asString());
+	if(it != entries.end())
+	{
+		if(it->second->getBlocked()) return 2;
+		U32 eTime=it->second->getEntryTime();
+		U32 currentTime=time(0);
+		if((currentTime-eTime) <= queueTime)
+		{
+			it->second->updateEntryAmount();
+			U32 eAmount=it->second->getEntryAmount();
+			if(eAmount > (queueAmount*multiplier))
+			{
+				it->second->setBlocked();
+				return 1;
+			}
+			else
+				return 0;
+		}
+		else
+		{
+			it->second->clearEntry();
+			it->second->updateEntryAmount();
+			it->second->updateEntryTime();
+			return 0;
+		}
+	}
+	else
+	{
+		entries[name.asString()]=new NACLAntiSpamQueueEntry();
+		entries[name.asString()]->updateEntryAmount();
+		entries[name.asString()]->updateEntryTime();
+		return 0;
+	}
+}
+
+// NaClAntiSpamRegistry
+
+static const char* QUEUE_NAME[NACLAntiSpamRegistry::QUEUE_MAX] = {
+"Chat",
+"Inventory",
+"Instant Message",
+"Calling Card",
+"Sound",
+"Sound Preload",
+"Script Dialog",
+"Teleport"};
+
+NACLAntiSpamRegistry::NACLAntiSpamRegistry(U32 time, U32 amount)
+{
+	globalTime=time;
+	globalAmount=amount;
+	static LLCachedControl<bool> _NACL_AntiSpamGlobalQueue(gSavedSettings,"_NACL_AntiSpamGlobalQueue");
+	bGlobalQueue=_NACL_AntiSpamGlobalQueue;
+	for(int queue = 0; queue < QUEUE_MAX; ++queue)
+	{
+		queues[queue] = new NACLAntiSpamQueue(time,amount);
+	}
+}
+const char* NACLAntiSpamRegistry::getQueueName(U32 queue_id)
+{
+	if(queue_id >= QUEUE_MAX)
+		return "Unknown";
+	return QUEUE_NAME[queue_id];
+}
+void NACLAntiSpamRegistry::registerQueues(U32 time, U32 amount)
+{
+	globalTime=time;
+	globalAmount=amount;
+	static LLCachedControl<bool> _NACL_AntiSpamGlobalQueue(gSavedSettings,"_NACL_AntiSpamGlobalQueue");
+	bGlobalQueue=_NACL_AntiSpamGlobalQueue;
+	for(int queue = 0; queue < QUEUE_MAX; ++queue)
+	{
+		queues[queue] = new NACLAntiSpamQueue(time,amount);
+	}
+}
+void NACLAntiSpamRegistry::registerQueue(U32 name, U32 time, U32 amount)
+{
+	/*
+	it=queues.find(name);
+	if(it == queues.end())
+	{
+		queues[name]=new NACLAntiSpamQueue(time,amount);
+	}
+	*/
+}
+void NACLAntiSpamRegistry::setRegisteredQueueTime(U32 name, U32 time)
+{
+	if(name >= QUEUE_MAX || queues[name] == 0)
+	{
+		LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+		return;
+	}
+	
+	queues[name]->setTime(time);
+}
+void NACLAntiSpamRegistry::setRegisteredQueueAmount(U32 name, U32 amount)
+{
+	if(name >= QUEUE_MAX || queues[name] == 0)
+	{
+		LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+		return;
+	}
+	
+	queues[name]->setAmount(amount);
+}
+void NACLAntiSpamRegistry::setAllQueueTimes(U32 time)
+{
+	globalTime=time;
+	for(int queue = 0; queue < QUEUE_MAX; ++queue)
+		queues[queue]->setTime(time);
+}
+void NACLAntiSpamRegistry::setAllQueueAmounts(U32 amount)
+{
+	globalAmount=amount;
+	for(int queue = 0; queue < QUEUE_MAX; ++queue)
+	{
+		if(queue == QUEUE_SOUND || queue == QUEUE_SOUND_PRELOAD)
+			queues[queue]->setAmount(amount*5);
+		else
+			queues[queue]->setAmount(amount);
+	}
+}
+void NACLAntiSpamRegistry::clearRegisteredQueue(U32 name)
+{
+	if(name >= QUEUE_MAX || queues[name] == 0)
+	{
+		LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+		return;
+	}
+	
+	queues[name]->clearEntries();
+}
+void NACLAntiSpamRegistry::purgeRegisteredQueue(U32 name)
+{
+	if(name >= QUEUE_MAX || queues[name] == 0)
+	{
+		LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+		return;
+	}
+	
+	queues[name]->purgeEntries();
+}
+void NACLAntiSpamRegistry::blockOnQueue(U32 name, LLUUID& source)
+{
+	if(bGlobalQueue)
+	{
+		NACLAntiSpamRegistry::blockGlobalEntry(source);
+	}
+	else
+	{
+		if(name >= QUEUE_MAX || queues[name] == 0)
+		{
+			LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+			return;
+		}
+		queues[name]->blockEntry(source);
+	}
+}
+void NACLAntiSpamRegistry::blockGlobalEntry(LLUUID& source)
+{
+	it2=globalEntries.find(source.asString());
+	if(it2 == globalEntries.end())
+	{
+		globalEntries[source.asString()]=new NACLAntiSpamQueueEntry();
+	}
+	globalEntries[source.asString()]->setBlocked();
+}
+bool NACLAntiSpamRegistry::checkQueue(U32 name, LLUUID& source, U32 multiplier, bool silent)
+{
+	if(source.isNull()) return false;
+	if(gAgent.getID() == source) return false;
+	LLViewerObject *obj=gObjectList.findObject(source);
+	if(obj)
+		if(obj->permYouOwner()) return false;
+	
+	int result;
+	if(bGlobalQueue)
+	{
+		result=NACLAntiSpamRegistry::checkGlobalEntry(source,multiplier);
+	}
+	else
+	{
+		if(name >= QUEUE_MAX || queues[name] == 0)
+		{
+			LL_ERRS("AntiSpam") << "CODE BUG: Attempting to use a antispam queue that was not created or was outside of the reasonable range of queues. Queue: " << getQueueName(name) << llendl;
+			return false;
+		}
+		result=queues[name]->checkEntry(source,multiplier);
+	}
+	if(result==0)
+	{
+		return false;
+	}
+	else if(result==2)
+	{
+		return true;
+	}
+	else
+	{
+		if(!silent)
+		{
+		LLSD args;
+		args["MESSAGE"] = std::string(getQueueName(name))+": Blocked object "+source.asString();
+		LLNotificationsUtil::add("SystemMessageTip", args);
+		}
+		return true;
+	}
+}
+
+// Global queue stoof
+void NACLAntiSpamRegistry::setGlobalQueue(bool value)
+{
+	NACLAntiSpamRegistry::purgeAllQueues();
+	bGlobalQueue=value;
+}
+void NACLAntiSpamRegistry::setGlobalAmount(U32 amount)
+{
+	globalAmount=amount;
+}
+void NACLAntiSpamRegistry::setGlobalTime(U32 time)
+{
+	globalTime=time;
+}
+void NACLAntiSpamRegistry::clearAllQueues()
+{
+	if(bGlobalQueue)
+		NACLAntiSpamRegistry::clearGlobalEntries();
+	else
+	for(int queue = 0; queue < QUEUE_MAX; ++queue)
+	{
+		queues[queue]->clearEntries();
+	}
+}
+void NACLAntiSpamRegistry::purgeAllQueues()
+{
+	if(bGlobalQueue)
+		NACLAntiSpamRegistry::purgeGlobalEntries();
+	else
+		for(int queue = 0; queue < QUEUE_MAX; ++queue)
+		{
+			queues[queue]->purgeEntries();
+		}
+}
+int NACLAntiSpamRegistry::checkGlobalEntry(LLUUID& name, U32 multiplier)
+{
+	it2=globalEntries.find(name.asString());
+	if(it2 != globalEntries.end())
+	{
+		if(it2->second->getBlocked()) return 2;
+		U32 eTime=it2->second->getEntryTime();
+		U32 currentTime=time(0);
+		if((currentTime-eTime) <= globalTime)
+		{
+			it2->second->updateEntryAmount();
+			U32 eAmount=it2->second->getEntryAmount();
+			if(eAmount > (globalAmount*multiplier))
+				return 1;
+			else
+				return 0;
+		}
+		else
+		{
+			it2->second->clearEntry();
+			it2->second->updateEntryAmount();
+			it2->second->updateEntryTime();
+			return 0;
+		}
+	}
+	else
+	{
+		globalEntries[name.asString()]=new NACLAntiSpamQueueEntry();
+		globalEntries[name.asString()]->updateEntryAmount();
+		globalEntries[name.asString()]->updateEntryTime();
+		return 0;
+	}
+}
+void NACLAntiSpamRegistry::clearGlobalEntries()
+{
+	for(it2 = globalEntries.begin(); it2 != globalEntries.end(); it2++)
+	{
+		it2->second->clearEntry();
+	}
+}
+void NACLAntiSpamRegistry::purgeGlobalEntries()
+{
+	for(it2 = globalEntries.begin(); it2 != globalEntries.end(); it2++)
+	{
+		delete it2->second;
+		it2->second = 0;
+	}
+	globalEntries.clear();
+}
+bool NACLAntiSpamRegistry::handleNaclAntiSpamGlobalQueueChanged(const LLSD& newvalue)
+{
+    setGlobalQueue(newvalue.asBoolean());
+    return true;
+}
+bool NACLAntiSpamRegistry::handleNaclAntiSpamTimeChanged(const LLSD& newvalue)
+{
+    setAllQueueTimes(newvalue.asInteger());
+    return true;
+}
+bool NACLAntiSpamRegistry::handleNaclAntiSpamAmountChanged(const LLSD& newvalue)
+{
+    setAllQueueAmounts(newvalue.asInteger());
+    return true;
+}
+

indra/newview/NACLantispam.h

@@ -0,0 +1,93 @@
+#ifndef NACLANTISPAM_H
+#define NACLANTISPAM_H
+#include <boost/tr1/unordered_map.hpp>
+#include "stdtypes.h"
+#include "lluuid.h"
+class NACLAntiSpamQueueEntry
+{
+	friend class NACLAntiSpamQueue;
+	friend class NACLAntiSpamRegistry;
+protected:
+	NACLAntiSpamQueueEntry();
+	void clearEntry();
+	U32 getEntryAmount();
+	U32 getEntryTime();
+	void updateEntryAmount();
+	void updateEntryTime();
+	bool getBlocked();
+	void setBlocked();
+private:
+	U32 entryAmount;
+	U32 entryTime;
+	bool blocked;
+};
+class NACLAntiSpamQueue
+{
+	friend class NACLAntiSpamRegistry;
+protected:
+	NACLAntiSpamQueue(U32 time, U32 amount);
+	void setAmount(U32 amount);
+	void setTime(U32 time);
+	void clearEntries();
+	void purgeEntries();
+	void blockEntry(LLUUID& source);
+	int checkEntry(LLUUID& source, U32 multiplier);
+private:
+	std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*> entries;
+	std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*>::iterator it;
+	U32 queueAmount;
+	U32 queueTime;
+};
+class NACLAntiSpamRegistry
+{
+public:
+	NACLAntiSpamRegistry(U32 time=2, U32 amount=10);
+	static void registerQueues(U32 time=2, U32 amount=10);
+	static void registerQueue(U32 name, U32 time, U32 amount);
+	static void setRegisteredQueueTime(U32 name, U32 time);
+	static void setRegisteredQueueAmount(U32 name,U32 amount);
+	static void setAllQueueTimes(U32 amount);
+	static void setAllQueueAmounts(U32 time);
+	static bool checkQueue(U32 name, LLUUID& source, U32 multiplier=1, bool silent=false);
+	static bool handleNaclAntiSpamGlobalQueueChanged(const LLSD& newvalue);
+	static bool handleNaclAntiSpamTimeChanged(const LLSD& newvalue);
+	static bool handleNaclAntiSpamAmountChanged(const LLSD& newvalue);
+	static void clearRegisteredQueue(U32 name);
+	static void purgeRegisteredQueue(U32 name);
+	static void clearAllQueues();
+	static void purgeAllQueues();
+	static void setGlobalQueue(bool value);
+	static void setGlobalAmount(U32 amount);
+	static void setGlobalTime(U32 time);
+	static void blockOnQueue(U32 name,LLUUID& owner_id);
+	enum {
+		QUEUE_CHAT,
+		QUEUE_INVENTORY,
+		QUEUE_IM,
+		QUEUE_CALLING_CARD,
+		QUEUE_SOUND,
+		QUEUE_SOUND_PRELOAD,
+		QUEUE_SCRIPT_DIALOG,
+		QUEUE_TELEPORT,
+		QUEUE_MAX
+	};
+private:
+	static const char* getQueueName(U32 queue_id);
+	static NACLAntiSpamQueue* queues[QUEUE_MAX];
+	static std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*> globalEntries;
+	static std::tr1::unordered_map<std::string,NACLAntiSpamQueueEntry*>::iterator it2;
+	static U32 globalTime;
+	static U32 globalAmount;
+	static bool bGlobalQueue;
+
+	static int checkGlobalEntry(LLUUID& source, U32 multiplier);
+	static void clearGlobalEntries();
+	static void purgeGlobalEntries();
+	static void blockGlobalEntry(LLUUID& source);
+};
+
+
+extern const std::string COLLISION_SOUNDS[];
+extern const int COLLISION_SOUNDS_SIZE;
+
+#endif //NACLANTISPAM_H

indra/newview/app_settings/client_tags_sg1.xml

@@ -786,6 +786,18 @@
         <real>0.7843137254902</real>
         <real>1</real>
       </array>
+    </map>
+	<key>5886ec80-cf56-11e1-9b23-0800200c9a66</key>
+    <map>
+      <key>name</key>
+      <string>Voodoo</string>
+      <key>color</key>
+      <array>
+        <real>0.70588235294118</real>
+        <real>0.7843137254902</real>
+        <real>0.7843137254902</real>
+        <real>1</real>
+      </array>
     </map>
     <key>734bae36-a197-b087-ee2d-a098d58fed55</key>
     <map>

indra/newview/app_settings/settings.xml

@@ -8,7 +8,6 @@
 		<string>settings_sh.xml</string>
 		<string>settings_rlv.xml</string>
 	</array>
-	
 	<key>SianaRenderDeferredInvisiprim</key>
 	<map>
 	  <key>Comment</key>
@@ -894,6 +893,83 @@
       <string>Boolean</string>
       <key>Value</key>
       <integer>1</integer>
+    </map>
+	<key>_NACL_Antispam</key>
+    <map>
+      <key>Comment</key>
+      <string>When true, all dialogs will be blocked, resets on restart.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>_NACL_AntiSpamGlobalQueue</key>
+    <map>
+        <key>Comment</key>
+        <string> </string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>Boolean</string>
+        <key>Value</key>
+        <integer>0</integer>
+    </map>
+    <key>_NACL_AntiSpamTime</key>
+    <map>
+        <key>Comment</key>
+        <string> </string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>U32</string>
+        <key>Value</key>
+        <integer>2</integer>
+    </map>
+        <key>_NACL_AntiSpamAmount</key>
+        <map>
+        <key>Comment</key>
+        <string> </string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>U32</string>
+        <key>Value</key>
+        <integer>10</integer>
+    </map>
+        <key>_NACL_AntiSpamSoundMulti</key>
+        <map>
+        <key>Comment</key>
+        <string> </string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>U32</string>
+        <key>Value</key>
+        <integer>4</integer>
+    </map>
+        <key>_NACL_AntiSpamNewlines</key>
+        <map>
+        <key>Comment</key>
+        <string>How many newlines a message can have before it's considered spam.</string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>U32</string>
+        <key>Value</key>
+        <integer>30</integer>
+    </map>
+    <key>_NACL_AntiSpamSoundPreloadMulti</key>
+    <map>
+        <key>Comment</key>
+        <string> </string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>U32</string>
+        <key>Value</key>
+        <integer>4</integer>
     </map>
     <!-- Vanilla SL settings that are now optionally Account-Specific -->
     <key>AgentChatColor</key>
@@ -1725,6 +1801,17 @@
       <key>Value</key>
       <real>1.0</real>
     </map>
+    <key>AudioLevelUnderwaterRolloff</key>
+    <map>
+      <key>Comment</key>
+      <string>Controls the distance-based dropoff of audio volume when camera is submerged (fraction or multiple of default audio rolloff)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>4.0</real>
+    </map>
     <key>AudioLevelSFX</key>
     <map>
       <key>Comment</key>
@@ -1796,7 +1883,7 @@
       <key>Comment</key>
       <string>Enable texture auditting.</string>
       <key>Persist</key>
-      <integer>1</integer>
+      <integer>0</integer>
       <key>Type</key>
       <string>Boolean</string>
       <key>Value</key>
@@ -15097,3 +15184,4 @@
     </map>
   </map>
 </llsd>
+