1HEADmaster

1 files changed, 275 insertions, 0 deletions

diff --git a/external/vpc/public/vstdlib/vstrtools.h b/external/vpc/public/vstdlib/vstrtools.h
new file mode 100644
index 0000000..04b351c
--- /dev/null
+++ b/external/vpc/public/vstdlib/vstrtools.h
@@ -0,0 +1,275 @@
+//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
+// 
+// Functions for UCS/UTF/Unicode string operations. These functions are in vstdlib
+// instead of tier1, because on PS/3 they need to load and initialize a system module,
+// which is more frugal to do from a single place rather than multiple times in different PRX'es.
+// The functions themselves aren't supposed to be called frequently enough for the DLL/PRX boundary
+// marshalling, if any, to have any measureable impact on performance.
+//
+#ifndef VSTRTOOLS_HDR
+#define VSTRTOOLS_HDR
+
+#include "tier0/platform.h"
+#include "tier0/basetypes.h"
+#include "tier1/strtools.h"
+
+#ifdef STATIC_VSTDLIB
+#define VSTRTOOLS_INTERFACE
+#else
+#ifdef VSTDLIB_DLL_EXPORT
+#define VSTRTOOLS_INTERFACE DLL_EXPORT
+#else
+#define VSTRTOOLS_INTERFACE DLL_IMPORT
+#endif
+#endif
+
+// conversion functions wchar_t <-> char, returning the number of characters converted
+VSTRTOOLS_INTERFACE int V_UTF8ToUnicode( const char *pUTF8, wchar_t *pwchDest, int cubDestSizeInBytes );
+VSTRTOOLS_INTERFACE int V_UnicodeToUTF8( const wchar_t *pUnicode, char *pUTF8, int cubDestSizeInBytes );
+VSTRTOOLS_INTERFACE int V_UCS2ToUnicode( const ucs2 *pUCS2, wchar_t *pUnicode, int cubDestSizeInBytes );
+VSTRTOOLS_INTERFACE int V_UCS2ToUTF8( const ucs2 *pUCS2, char *pUTF8, int cubDestSizeInBytes );
+VSTRTOOLS_INTERFACE int V_UnicodeToUCS2( const wchar_t *pUnicode, int cubSrcInBytes, char *pUCS2, int cubDestSizeInBytes );
+VSTRTOOLS_INTERFACE int V_UTF8ToUCS2( const char *pUTF8, int cubSrcInBytes, ucs2 *pUCS2, int cubDestSizeInBytes );
+
+// copy at most n bytes into destination, will not corrupt utf-8 multi-byte sequences
+VSTRTOOLS_INTERFACE void * V_UTF8_strncpy( char *pDest, const char *pSrc, size_t nMaxBytes );
+
+
+//
+// This utility class is for performing UTF-8 <-> UTF-16 conversion.
+// It is intended for use with function/method parameters.
+//
+// For example, you can call
+//     FunctionTakingUTF16( CStrAutoEncode( utf8_string ).ToWString() )
+// or
+//     FunctionTakingUTF8( CStrAutoEncode( utf16_string ).ToString() )
+//
+// The converted string is allocated off the heap, and destroyed when
+// the object goes out of scope.
+//
+// if the string cannot be converted, NULL is returned.
+//
+// This class doesn't have any conversion operators; the intention is
+// to encourage the developer to get used to having to think about which
+// encoding is desired.
+//
+class CStrAutoEncode
+{
+public:
+
+	// ctor
+	explicit CStrAutoEncode( const char *pch )
+	{
+		m_pch = pch;
+		m_pwch = NULL;
+#if !defined( WIN32 ) && !defined(_WIN32)
+		m_pucs2 = NULL;
+		m_bCreatedUCS2 = false;
+#endif
+		m_bCreatedUTF16 = false;
+	}
+
+	// ctor
+	explicit CStrAutoEncode( const wchar_t *pwch )
+	{
+		m_pch = NULL;
+		m_pwch = pwch;
+#if !defined( WIN32 ) && !defined(_WIN32)
+		m_pucs2 = NULL;
+		m_bCreatedUCS2 = false;
+#endif
+		m_bCreatedUTF16 = true;
+	}
+
+#if !defined(WIN32) && !defined(_WINDOWS) && !defined(_WIN32) && !defined(_PS3)
+	explicit CStrAutoEncode( const ucs2 *pwch )
+	{
+		m_pch = NULL;
+		m_pwch = NULL;
+		m_pucs2 = pwch;
+		m_bCreatedUCS2 = true;
+		m_bCreatedUTF16 = false;
+	}
+#endif
+
+	// returns the UTF-8 string, converting on the fly.
+	const char* ToString()
+	{
+		PopulateUTF8();
+		return m_pch;
+	}
+
+	// returns the UTF-8 string - a writable pointer.
+	// only use this if you don't want to call const_cast
+	// yourself. We need this for cases like CreateProcess.
+	char* ToStringWritable()
+	{
+		PopulateUTF8();
+		return const_cast< char* >( m_pch );
+	}
+
+	// returns the UTF-16 string, converting on the fly.
+	const wchar_t* ToWString()
+	{
+		PopulateUTF16();
+		return m_pwch;
+	}
+
+#if !defined( WIN32 ) && !defined(_WIN32)
+	// returns the UTF-16 string, converting on the fly.
+	const ucs2* ToUCS2String()
+	{
+		PopulateUCS2();
+		return m_pucs2;
+	}
+#endif
+
+	// returns the UTF-16 string - a writable pointer.
+	// only use this if you don't want to call const_cast
+	// yourself. We need this for cases like CreateProcess.
+	wchar_t* ToWStringWritable()
+	{
+		PopulateUTF16();
+		return const_cast< wchar_t* >( m_pwch );
+	}
+
+	// dtor
+	~CStrAutoEncode()
+	{
+		// if we're "native unicode" then the UTF-8 string is something we allocated,
+		// and vice versa.
+		if ( m_bCreatedUTF16 )
+		{
+			delete [] m_pch;
+		}
+		else
+		{
+			delete [] m_pwch;
+		}
+#if !defined( WIN32 ) && !defined(_WIN32)
+		if ( !m_bCreatedUCS2 && m_pucs2 )
+			delete [] m_pucs2;
+#endif
+	}
+
+private:
+	// ensure we have done any conversion work required to farm out a
+	// UTF-8 encoded string.
+	//
+	// We perform two heap allocs here; the first one is the worst-case
+	// (four bytes per Unicode code point). This is usually quite pessimistic,
+	// so we perform a second allocation that's just the size we need.
+	void PopulateUTF8()
+	{
+		if ( !m_bCreatedUTF16 )
+			return;					// no work to do
+		if ( m_pwch == NULL )
+			return;					// don't have a UTF-16 string to convert
+		if ( m_pch != NULL )
+			return;					// already been converted to UTF-8; no work to do
+
+		// each Unicode code point can expand to as many as four bytes in UTF-8; we
+		// also need to leave room for the terminating NUL.
+		uint32 cbMax = 4 * static_cast<uint32>( V_wcslen( m_pwch ) ) + 1;
+		char *pchTemp = new char[ cbMax ];
+		if ( V_UnicodeToUTF8( m_pwch, pchTemp, cbMax ) )
+		{
+			uint32 cchAlloc = static_cast<uint32>( V_strlen( pchTemp ) ) + 1;
+			char *pchHeap = new char[ cchAlloc ];
+			V_strncpy( pchHeap, pchTemp, cchAlloc );
+			delete [] pchTemp;
+			m_pch = pchHeap;
+		}
+		else
+		{
+			// do nothing, and leave the UTF-8 string NULL
+			delete [] pchTemp;
+		}
+	}
+
+	// ensure we have done any conversion work required to farm out a
+	// UTF-16 encoded string.
+	//
+	// We perform two heap allocs here; the first one is the worst-case
+	// (one code point per UTF-8 byte). This is sometimes pessimistic,
+	// so we perform a second allocation that's just the size we need.
+	void PopulateUTF16()
+	{
+		if ( m_bCreatedUTF16 )
+			return;					// no work to do
+		if ( m_pch == NULL )
+			return;					// no UTF-8 string to convert
+		if ( m_pwch != NULL )
+			return;					// already been converted to UTF-16; no work to do
+
+		uint32 cchMax = static_cast<uint32>( V_strlen( m_pch ) ) + 1;
+		wchar_t *pwchTemp = new wchar_t[ cchMax ];
+		if ( V_UTF8ToUnicode( m_pch, pwchTemp, cchMax * sizeof( wchar_t ) ) )
+		{
+			uint32 cchAlloc = static_cast<uint32>( V_wcslen( pwchTemp ) ) + 1;
+			wchar_t *pwchHeap = new wchar_t[ cchAlloc ];
+			V_wcsncpy( pwchHeap, pwchTemp, cchAlloc * sizeof( wchar_t ) );
+			delete [] pwchTemp;
+			m_pwch = pwchHeap;
+		}
+		else
+		{
+			// do nothing, and leave the UTF-16 string NULL
+			delete [] pwchTemp;
+		}
+	}
+
+#if !defined( WIN32 ) && !defined(_WIN32)
+	// ensure we have done any conversion work required to farm out a
+	// UTF-16 encoded string.
+	//
+	// We perform two heap allocs here; the first one is the worst-case
+	// (one code point per UTF-8 byte). This is sometimes pessimistic,
+	// so we perform a second allocation that's just the size we need.
+	void PopulateUCS2()
+	{
+		if ( m_bCreatedUCS2 )
+			return;
+		if ( m_pch == NULL )
+			return;					// no UTF-8 string to convert
+		if ( m_pucs2 != NULL )
+			return;					// already been converted to UTF-16; no work to do
+
+		uint32 cchMax = static_cast<uint32>( V_strlen( m_pch ) ) + 1;
+		ucs2 *pwchTemp = new ucs2[ cchMax ];
+		if ( V_UTF8ToUCS2( m_pch, cchMax, pwchTemp, cchMax * sizeof( ucs2 ) ) )
+		{
+			uint32 cchAlloc = cchMax;
+			ucs2 *pwchHeap = new ucs2[ cchAlloc ];
+			memcpy( pwchHeap, pwchTemp, cchAlloc * sizeof( ucs2 ) );
+			delete [] pwchTemp;
+			m_pucs2 = pwchHeap;
+		}
+		else
+		{
+			// do nothing, and leave the UTF-16 string NULL
+			delete [] pwchTemp;
+		}
+	}
+#endif
+
+	// one of these pointers is an owned pointer; whichever
+	// one is the encoding OTHER than the one we were initialized
+	// with is the pointer we've allocated and must free.
+	const char *m_pch;
+	const wchar_t *m_pwch;
+#if !defined( WIN32 ) && !defined(_WIN32)
+	const ucs2 *m_pucs2;
+	bool m_bCreatedUCS2;
+#endif
+	// "created as UTF-16", means our owned string is the UTF-8 string not the UTF-16 one.
+	bool m_bCreatedUTF16;
+
+};
+
+
+#define V_UTF8ToUnicode			V_UTF8ToUnicode
+#define V_UnicodeToUTF8			V_UnicodeToUTF8
+
+
+#endif 
\ No newline at end of file