00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef OVR_Std_h
00018 #define OVR_Std_h
00019
00020 #include "OVR_Types.h"
00021 #include <stdarg.h>
00022 #include <string.h>
00023 #include <stdio.h>
00024 #include <stdlib.h>
00025 #include <ctype.h>
00026
00027 #if !defined(OVR_OS_WINCE) && defined(OVR_CC_MSVC) && (OVR_CC_MSVC >= 1400)
00028 #define OVR_MSVC_SAFESTRING
00029 #include <errno.h>
00030 #endif
00031
00032
00033 #include <wchar.h>
00034 #include <wctype.h>
00035
00036 namespace OVR {
00037
00038 #if defined(OVR_OS_WIN32)
00039 inline char* OVR_CDECL OVR_itoa(int val, char *dest, UPInt destsize, int radix)
00040 {
00041 #if defined(OVR_MSVC_SAFESTRING)
00042 _itoa_s(val, dest, destsize, radix);
00043 return dest;
00044 #else
00045 OVR_UNUSED(destsize);
00046 return itoa(val, dest, radix);
00047 #endif
00048 }
00049 #else // OVR_OS_WIN32
00050 inline char* OVR_itoa(int val, char* dest, unsigned int len, int radix)
00051 {
00052 if (val == 0)
00053 {
00054 if (len > 1)
00055 {
00056 dest[0] = '0';
00057 dest[1] = '\0';
00058 }
00059 return dest;
00060 }
00061
00062 int cur = val;
00063 unsigned int i = 0;
00064 unsigned int sign = 0;
00065
00066 if (val < 0)
00067 {
00068 val = -val;
00069 sign = 1;
00070 }
00071
00072 while ((val != 0) && (i < (len - 1 - sign)))
00073 {
00074 cur = val % radix;
00075 val /= radix;
00076
00077 if (radix == 16)
00078 {
00079 switch(cur)
00080 {
00081 case 10:
00082 dest[i] = 'a';
00083 break;
00084 case 11:
00085 dest[i] = 'b';
00086 break;
00087 case 12:
00088 dest[i] = 'c';
00089 break;
00090 case 13:
00091 dest[i] = 'd';
00092 break;
00093 case 14:
00094 dest[i] = 'e';
00095 break;
00096 case 15:
00097 dest[i] = 'f';
00098 break;
00099 default:
00100 dest[i] = (char)('0' + cur);
00101 break;
00102 }
00103 }
00104 else
00105 {
00106 dest[i] = (char)('0' + cur);
00107 }
00108 ++i;
00109 }
00110
00111 if (sign)
00112 {
00113 dest[i++] = '-';
00114 }
00115
00116 for (unsigned int j = 0; j < i / 2; ++j)
00117 {
00118 char tmp = dest[j];
00119 dest[j] = dest[i - 1 - j];
00120 dest[i - 1 - j] = tmp;
00121 }
00122 dest[i] = '\0';
00123
00124 return dest;
00125 }
00126
00127 #endif
00128
00129
00130
00131
00132 inline UPInt OVR_CDECL OVR_strlen(const char* str)
00133 {
00134 return strlen(str);
00135 }
00136
00137 inline char* OVR_CDECL OVR_strcpy(char* dest, UPInt destsize, const char* src)
00138 {
00139 #if defined(OVR_MSVC_SAFESTRING)
00140 strcpy_s(dest, destsize, src);
00141 return dest;
00142 #else
00143 OVR_UNUSED(destsize);
00144 return strcpy(dest, src);
00145 #endif
00146 }
00147
00148 inline char* OVR_CDECL OVR_strncpy(char* dest, UPInt destsize, const char* src, UPInt count)
00149 {
00150 #if defined(OVR_MSVC_SAFESTRING)
00151 strncpy_s(dest, destsize, src, count);
00152 return dest;
00153 #else
00154 OVR_UNUSED(destsize);
00155 return strncpy(dest, src, count);
00156 #endif
00157 }
00158
00159 inline char * OVR_CDECL OVR_strcat(char* dest, UPInt destsize, const char* src)
00160 {
00161 #if defined(OVR_MSVC_SAFESTRING)
00162 strcat_s(dest, destsize, src);
00163 return dest;
00164 #else
00165 OVR_UNUSED(destsize);
00166 return strcat(dest, src);
00167 #endif
00168 }
00169
00170 inline int OVR_CDECL OVR_strcmp(const char* dest, const char* src)
00171 {
00172 return strcmp(dest, src);
00173 }
00174
00175 inline const char* OVR_CDECL OVR_strchr(const char* str, char c)
00176 {
00177 return strchr(str, c);
00178 }
00179
00180 inline char* OVR_CDECL OVR_strchr(char* str, char c)
00181 {
00182 return strchr(str, c);
00183 }
00184
00185 inline const char* OVR_strrchr(const char* str, char c)
00186 {
00187 UPInt len = OVR_strlen(str);
00188 for (UPInt i=len; i>0; i--)
00189 if (str[i]==c)
00190 return str+i;
00191 return 0;
00192 }
00193
00194 inline const UByte* OVR_CDECL OVR_memrchr(const UByte* str, UPInt size, UByte c)
00195 {
00196 for (SPInt i = (SPInt)size - 1; i >= 0; i--)
00197 {
00198 if (str[i] == c)
00199 return str + i;
00200 }
00201 return 0;
00202 }
00203
00204 inline char* OVR_CDECL OVR_strrchr(char* str, char c)
00205 {
00206 UPInt len = OVR_strlen(str);
00207 for (UPInt i=len; i>0; i--)
00208 if (str[i]==c)
00209 return str+i;
00210 return 0;
00211 }
00212
00213
00214 double OVR_CDECL OVR_strtod(const char* string, char** tailptr);
00215
00216 inline long OVR_CDECL OVR_strtol(const char* string, char** tailptr, int radix)
00217 {
00218 return strtol(string, tailptr, radix);
00219 }
00220
00221 inline long OVR_CDECL OVR_strtoul(const char* string, char** tailptr, int radix)
00222 {
00223 return strtoul(string, tailptr, radix);
00224 }
00225
00226 inline int OVR_CDECL OVR_strncmp(const char* ws1, const char* ws2, UPInt size)
00227 {
00228 return strncmp(ws1, ws2, size);
00229 }
00230
00231 inline UInt64 OVR_CDECL OVR_strtouq(const char *nptr, char **endptr, int base)
00232 {
00233 #if defined(OVR_CC_MSVC) && !defined(OVR_OS_WINCE)
00234 return _strtoui64(nptr, endptr, base);
00235 #else
00236 return strtoull(nptr, endptr, base);
00237 #endif
00238 }
00239
00240 inline SInt64 OVR_CDECL OVR_strtoq(const char *nptr, char **endptr, int base)
00241 {
00242 #if defined(OVR_CC_MSVC) && !defined(OVR_OS_WINCE)
00243 return _strtoi64(nptr, endptr, base);
00244 #else
00245 return strtoll(nptr, endptr, base);
00246 #endif
00247 }
00248
00249
00250 inline SInt64 OVR_CDECL OVR_atoq(const char* string)
00251 {
00252 #if defined(OVR_CC_MSVC) && !defined(OVR_OS_WINCE)
00253 return _atoi64(string);
00254 #else
00255 return atoll(string);
00256 #endif
00257 }
00258
00259 inline UInt64 OVR_CDECL OVR_atouq(const char* string)
00260 {
00261 return OVR_strtouq(string, NULL, 10);
00262 }
00263
00264
00265
00266 int OVR_CDECL OVR_stricmp(const char* dest, const char* src);
00267 int OVR_CDECL OVR_strnicmp(const char* dest, const char* src, UPInt count);
00268
00269 inline UPInt OVR_CDECL OVR_sprintf(char *dest, UPInt destsize, const char* format, ...)
00270 {
00271 va_list argList;
00272 va_start(argList,format);
00273 UPInt ret;
00274 #if defined(OVR_CC_MSVC)
00275 #if defined(OVR_MSVC_SAFESTRING)
00276 ret = _vsnprintf_s(dest, destsize, _TRUNCATE, format, argList);
00277 OVR_ASSERT(ret != -1);
00278 #else
00279 OVR_UNUSED(destsize);
00280 ret = _vsnprintf(dest, destsize - 1, format, argList);
00281 OVR_ASSERT(ret != -1);
00282 dest[destsize-1] = 0;
00283 #endif
00284 #else
00285 OVR_UNUSED(destsize);
00286 ret = vsprintf(dest, format, argList);
00287 OVR_ASSERT(ret < destsize);
00288 #endif
00289 va_end(argList);
00290 return ret;
00291 }
00292
00293 inline UPInt OVR_CDECL OVR_vsprintf(char *dest, UPInt destsize, const char * format, va_list argList)
00294 {
00295 UPInt ret;
00296 #if defined(OVR_CC_MSVC)
00297 #if defined(OVR_MSVC_SAFESTRING)
00298 dest[0] = '\0';
00299 int rv = vsnprintf_s(dest, destsize, _TRUNCATE, format, argList);
00300 if (rv == -1)
00301 {
00302 dest[destsize - 1] = '\0';
00303 ret = destsize - 1;
00304 }
00305 else
00306 ret = (UPInt)rv;
00307 #else
00308 OVR_UNUSED(destsize);
00309 int rv = _vsnprintf(dest, destsize - 1, format, argList);
00310 OVR_ASSERT(rv != -1);
00311 ret = (UPInt)rv;
00312 dest[destsize-1] = 0;
00313 #endif
00314 #else
00315 OVR_UNUSED(destsize);
00316 ret = (UPInt)vsprintf(dest, format, argList);
00317 OVR_ASSERT(ret < destsize);
00318 #endif
00319 return ret;
00320 }
00321
00322
00323 inline UPInt OVR_CDECL OVR_vscprintf(const char * format, va_list argList)
00324 {
00325 UPInt ret;
00326 #if defined(OVR_CC_MSVC)
00327 ret = (UPInt) _vscprintf(format, argList);
00328 #else
00329 ret = (UPInt) vsnprintf(NULL, 0, format, argList);
00330 #endif
00331 return ret;
00332 }
00333
00334
00335 wchar_t* OVR_CDECL OVR_wcscpy(wchar_t* dest, UPInt destsize, const wchar_t* src);
00336 wchar_t* OVR_CDECL OVR_wcsncpy(wchar_t* dest, UPInt destsize, const wchar_t* src, UPInt count);
00337 wchar_t* OVR_CDECL OVR_wcscat(wchar_t* dest, UPInt destsize, const wchar_t* src);
00338 UPInt OVR_CDECL OVR_wcslen(const wchar_t* str);
00339 int OVR_CDECL OVR_wcscmp(const wchar_t* a, const wchar_t* b);
00340 int OVR_CDECL OVR_wcsicmp(const wchar_t* a, const wchar_t* b);
00341
00342 inline int OVR_CDECL OVR_wcsicoll(const wchar_t* a, const wchar_t* b)
00343 {
00344 #if defined(OVR_OS_WIN32)
00345 #if defined(OVR_CC_MSVC) && (OVR_CC_MSVC >= 1400)
00346 return ::_wcsicoll(a, b);
00347 #else
00348 return ::wcsicoll(a, b);
00349 #endif
00350 #else
00351
00352 return OVR_wcsicmp(a, b);
00353 #endif
00354 }
00355
00356 inline int OVR_CDECL OVR_wcscoll(const wchar_t* a, const wchar_t* b)
00357 {
00358 #if defined(OVR_OS_WIN32) || defined(OVR_OS_LINUX)
00359 return wcscoll(a, b);
00360 #else
00361
00362 return OVR_wcscmp(a, b);
00363 #endif
00364 }
00365
00366 #ifndef OVR_NO_WCTYPE
00367
00368 inline int OVR_CDECL UnicodeCharIs(const UInt16* table, wchar_t charCode)
00369 {
00370 unsigned offset = table[charCode >> 8];
00371 if (offset == 0) return 0;
00372 if (offset == 1) return 1;
00373 return (table[offset + ((charCode >> 4) & 15)] & (1 << (charCode & 15))) != 0;
00374 }
00375
00376 extern const UInt16 UnicodeAlnumBits[];
00377 extern const UInt16 UnicodeAlphaBits[];
00378 extern const UInt16 UnicodeDigitBits[];
00379 extern const UInt16 UnicodeSpaceBits[];
00380 extern const UInt16 UnicodeXDigitBits[];
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390 inline int OVR_CDECL OVR_iswalnum (wchar_t charCode) { return UnicodeCharIs(UnicodeAlnumBits, charCode); }
00391 inline int OVR_CDECL OVR_iswalpha (wchar_t charCode) { return UnicodeCharIs(UnicodeAlphaBits, charCode); }
00392 inline int OVR_CDECL OVR_iswdigit (wchar_t charCode) { return UnicodeCharIs(UnicodeDigitBits, charCode); }
00393 inline int OVR_CDECL OVR_iswspace (wchar_t charCode) { return UnicodeCharIs(UnicodeSpaceBits, charCode); }
00394 inline int OVR_CDECL OVR_iswxdigit(wchar_t charCode) { return UnicodeCharIs(UnicodeXDigitBits, charCode); }
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404 int OVR_CDECL OVR_towupper(wchar_t charCode);
00405 int OVR_CDECL OVR_towlower(wchar_t charCode);
00406
00407 #else // OVR_NO_WCTYPE
00408
00409 inline int OVR_CDECL OVR_iswspace(wchar_t c)
00410 {
00411 return iswspace(c);
00412 }
00413
00414 inline int OVR_CDECL OVR_iswdigit(wchar_t c)
00415 {
00416 return iswdigit(c);
00417 }
00418
00419 inline int OVR_CDECL OVR_iswxdigit(wchar_t c)
00420 {
00421 return iswxdigit(c);
00422 }
00423
00424 inline int OVR_CDECL OVR_iswalpha(wchar_t c)
00425 {
00426 return iswalpha(c);
00427 }
00428
00429 inline int OVR_CDECL OVR_iswalnum(wchar_t c)
00430 {
00431 return iswalnum(c);
00432 }
00433
00434 inline wchar_t OVR_CDECL OVR_towlower(wchar_t c)
00435 {
00436 return (wchar_t)towlower(c);
00437 }
00438
00439 inline wchar_t OVR_towupper(wchar_t c)
00440 {
00441 return (wchar_t)towupper(c);
00442 }
00443
00444 #endif // OVR_NO_WCTYPE
00445
00446
00447 inline int OVR_CDECL OVR_tolower(int c)
00448 {
00449 return (c >= 'A' && c <= 'Z') ? c - 'A' + 'a' : c;
00450 }
00451
00452 inline int OVR_CDECL OVR_toupper(int c)
00453 {
00454 return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c;
00455 }
00456
00457
00458
00459 inline double OVR_CDECL OVR_wcstod(const wchar_t* string, wchar_t** tailptr)
00460 {
00461 #if defined(OVR_OS_OTHER)
00462 OVR_UNUSED(tailptr);
00463 char buffer[64];
00464 char* tp = NULL;
00465 UPInt max = OVR_wcslen(string);
00466 if (max > 63) max = 63;
00467 unsigned char c = 0;
00468 for (UPInt i=0; i < max; i++)
00469 {
00470 c = (unsigned char)string[i];
00471 buffer[i] = ((c) < 128 ? (char)c : '!');
00472 }
00473 buffer[max] = 0;
00474 return OVR_strtod(buffer, &tp);
00475 #else
00476 return wcstod(string, tailptr);
00477 #endif
00478 }
00479
00480 inline long OVR_CDECL OVR_wcstol(const wchar_t* string, wchar_t** tailptr, int radix)
00481 {
00482 #if defined(OVR_OS_OTHER)
00483 OVR_UNUSED(tailptr);
00484 char buffer[64];
00485 char* tp = NULL;
00486 UPInt max = OVR_wcslen(string);
00487 if (max > 63) max = 63;
00488 unsigned char c = 0;
00489 for (UPInt i=0; i < max; i++)
00490 {
00491 c = (unsigned char)string[i];
00492 buffer[i] = ((c) < 128 ? (char)c : '!');
00493 }
00494 buffer[max] = 0;
00495 return strtol(buffer, &tp, radix);
00496 #else
00497 return wcstol(string, tailptr, radix);
00498 #endif
00499 }
00500
00501 }
00502
00503 #endif // OVR_Std_h