1 //========= Copyright Valve Corporation ============//
2 #pragma once
3
4 #include <string>
5 #include <stdint.h>
6 #include <sys/types.h>
7 #include <vector>
8
9 /** returns true if the string has the prefix */
10 bool StringHasPrefix( const std::string & sString, const std::string & sPrefix );
11 bool StringHasPrefixCaseSensitive( const std::string & sString, const std::string & sPrefix );
12
13 /** returns if the string has the suffix */
14 bool StringHasSuffix( const std::string &sString, const std::string &sSuffix );
15 bool StringHasSuffixCaseSensitive( const std::string &sString, const std::string &sSuffix );
16
17 // Mozilla: see README.mozilla for more details
18 #if defined( _WIN32 )
19 /** converts a UTF-16 string to a UTF-8 string */
20 std::string UTF16to8( const wchar_t * in );
21 std::string UTF16to8( const std::wstring & in );
22
23 /** converts a UTF-8 string to a UTF-16 string */
24 std::wstring UTF8to16(const char * in);
25 std::wstring UTF8to16( const std::string & in );
26 #define Utf16FromUtf8 UTF8to16
27 #endif
28
29 #if defined( _WIN32 )
30 std::string DefaultACPtoUTF8( const char *pszStr );
31 #endif
32
33 /** Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere */
34 bool RepairUTF8( const char *begin, const char *end, std::string & sOutputUtf8 );
35 bool RepairUTF8( const std::string & sInputUtf8, std::string & sOutputUtf8 );
36
37 /** safely copy a string into a buffer */
38 void strcpy_safe( char *pchBuffer, size_t unBufferSizeBytes, const char *pchSource );
39 template< size_t bufferSize >
strcpy_safe(char (& buffer)[bufferSize],const char * pchSource)40 void strcpy_safe( char (& buffer) [ bufferSize ], const char *pchSource )
41 {
42 strcpy_safe( buffer, bufferSize, pchSource );
43 }
44
45
46 /** converts a string to upper case */
47 std::string StringToUpper( const std::string & sString );
48
49 /** converts a string to lower case */
50 std::string StringToLower( const std::string & sString );
51
52 // we stricmp (from WIN) but it isn't POSIX - OSX/LINUX have strcasecmp so just inline bridge to it
53 #if defined( OSX ) || defined( LINUX )
54 #include <strings.h>
stricmp(const char * pStr1,const char * pStr2)55 inline int stricmp(const char *pStr1, const char *pStr2) { return strcasecmp(pStr1,pStr2); }
56 #ifndef _stricmp
57 #define _stricmp stricmp
58 #endif
strnicmp(const char * pStr1,const char * pStr2,size_t unBufferLen)59 inline int strnicmp( const char *pStr1, const char *pStr2, size_t unBufferLen ) { return strncasecmp( pStr1,pStr2, unBufferLen ); }
60 #ifndef _strnicmp
61 #define _strnicmp strnicmp
62 #endif
63
64 #ifndef _vsnprintf_s
65 #define _vsnprintf_s vsnprintf
66 #endif
67
68 #define _TRUNCATE ((size_t)-1)
69
70 #endif
71
72 #if defined( OSX )
73 // behaviors ensure NULL-termination at least as well as _TRUNCATE does, but
74 // wcsncpy_s/strncpy_s can non-NULL-terminate, wcslcpy/strlcpy can not.
75 // inline errno_t wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
76 // {
77 // return wcslcpy(strDest, strSource, numberOfElements);
78 // }
79
80 // inline errno_t strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
81 // {
82 // return strlcpy(strDest, strSource, numberOfElements);
83 // }
84
85 #endif
86
87 #if defined( LINUX )
88 // this implementation does not return whether or not the destination was
89 // truncated, but that is straightforward to fix if anybody actually needs the
90 // return code.
91 #include "string.h"
wcsncpy_s(wchar_t * strDest,size_t numberOfElements,const wchar_t * strSource,size_t count)92 inline void wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
93 {
94 wcsncpy(strDest, strSource, numberOfElements);
95 strDest[numberOfElements-1] = '\0';
96 }
97
strncpy_s(char * strDest,size_t numberOfElements,const char * strSource,size_t count)98 inline void strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
99 {
100 strncpy(strDest, strSource, numberOfElements);
101 strDest[numberOfElements-1] = '\0';
102 }
103
104 #endif
105
106 #if defined( _WIN32 ) && _MSC_VER < 1800
strtoull(const char * str,char ** endptr,int base)107 inline uint64_t strtoull(const char *str, char **endptr, int base) { return _strtoui64( str, endptr, base ); }
108 #endif
109
110 /* Handles copying a std::string into a buffer as would be provided in an API */
111 uint32_t ReturnStdString( const std::string & sValue, char *pchBuffer, uint32_t unBufferLen );
112
113 /** Returns a std::string from a uint64_t */
114 // Mozilla: see README.mozilla for more details
115 //std::string Uint64ToString( uint64_t ulValue );
116
117 /** returns a uint64_t from a string */
118 uint64_t StringToUint64( const std::string & sValue );
119
120 //-----------------------------------------------------------------------------
121 // Purpose: Encodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.
122 // This version of the call isn't a strict RFC implementation, but uses + for space as is
123 // the standard in HTML form encoding, despite it not being part of the RFC.
124 //
125 // Dest buffer should be at least as large as source buffer to guarantee room for decode.
126 //-----------------------------------------------------------------------------
127 void V_URLEncode( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
128
129 /** Same as V_URLEncode, but without plus for space. */
130 void V_URLEncodeNoPlusForSpace( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
131
132 /** Same as V_URLEncodeNoPlusForSpace, but without escaping / and : */
133 void V_URLEncodeFullPath( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
134
135
136 //-----------------------------------------------------------------------------
137 // Purpose: Decodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.
138 // This version of the call isn't a strict RFC implementation, but uses + for space as is
139 // the standard in HTML form encoding, despite it not being part of the RFC.
140 //
141 // Dest buffer should be at least as large as source buffer to guarantee room for decode.
142 // Dest buffer being the same as the source buffer (decode in-place) is explicitly allowed.
143 //-----------------------------------------------------------------------------
144 size_t V_URLDecode( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen );
145
146 /** Same as V_URLDecode, but without plus for space. */
147 size_t V_URLDecodeNoPlusForSpace( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen );
148
149 //-----------------------------------------------------------------------------
150 // Purpose: strip extension from a path
151 //-----------------------------------------------------------------------------
152 void V_StripExtension( std::string &in );
153
154
155 /** Tokenizes a string into a vector of strings */
156 std::vector<std::string> TokenizeString( const std::string & sString, char cToken );
157