Initial commit

Torque/SDK/engine/platformMacCarb/macCarbStrings.cc

@@ -0,0 +1,509 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine 
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+
+#include "PlatformMacCarb/platformMacCarb.h"
+#include "platform/platform.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include "console/console.h"
+#include "platform/profiler.h"
+
+char *dStrdup_r(const char *src, const char *file, dsize_t line)
+{
+   char *buffer = (char *) dMalloc_r(dStrlen(src) + 1, file, line);
+   dStrcpy(buffer, src);
+   return buffer;
+}
+
+char *dStrnew(const char *src)
+{
+   char *buffer = new char[dStrlen(src) + 1];
+   dStrcpy(buffer, src);
+   return buffer;
+}
+
+char* dStrcat(char *dst, const char *src)
+{
+   return strcat(dst,src);
+}   
+
+char* dStrncat(char *dst, const char *src, dsize_t len)
+{
+   return strncat(dst,src,len);
+}
+
+// concatenates a list of src's onto the end of dst
+// the list of src's MUST be terminated by a NULL parameter
+// dStrcatl(dst, sizeof(dst), src1, src2, NULL);
+char* dStrcatl(char *dst, dsize_t dstSize, ...)
+{
+   const char* src;
+   char *p = dst;
+
+   AssertFatal(dstSize > 0, "dStrcatl: destination size is set zero");
+   dstSize--;  // leave room for string termination
+
+   // find end of dst
+   while (dstSize && *p++)                    
+      dstSize--;   
+   
+   va_list args;
+   va_start(args, dstSize);
+
+   // concatenate each src to end of dst
+   while ( (src = va_arg(args, const char*)) != NULL )
+      while( dstSize && *src )
+      {
+         *p++ = *src++;
+         dstSize--;   
+      }
+
+   va_end(args);
+
+   // make sure the string is terminated 
+   *p = 0;
+
+   return dst;
+}   
+
+
+// copy a list of src's into dst
+// the list of src's MUST be terminated by a NULL parameter
+// dStrccpyl(dst, sizeof(dst), src1, src2, NULL);
+char* dStrcpyl(char *dst, dsize_t dstSize, ...)
+{
+   const char* src;
+   char *p = dst;
+
+   AssertFatal(dstSize > 0, "dStrcpyl: destination size is set zero");
+   dstSize--;  // leave room for string termination
+
+   va_list args;
+   va_start(args, dstSize);
+
+   // concatenate each src to end of dst
+   while ( (src = va_arg(args, const char*)) != NULL )
+      while( dstSize && *src )
+      {
+         *p++ = *src++;
+         dstSize--;   
+      }
+
+   va_end(args);
+
+   // make sure the string is terminated 
+   *p = 0;
+
+   return dst;
+}   
+
+
+int dStrcmp(const char *str1, const char *str2)
+{
+   return strcmp(str1, str2);   
+}
+
+int dStrcmp( const UTF16 *str1, const UTF16 *str2)
+{
+   int ret;
+   const UTF16 *a, *b;
+   a = str1;
+   b = str2;
+
+   while( *a && *b && (ret = *a - *b) == 0)
+      a++, b++;
+
+   return ret;
+}  
+
+ 
+int dStricmp(const char *str1, const char *str2)
+{
+   char c1, c2;
+   while (1)
+   {
+      c1 = tolower(*str1++);
+      c2 = tolower(*str2++);
+      if (c1 < c2) return -1;
+      if (c1 > c2) return 1;
+      if (c1 == 0) return 0;
+   }
+}  
+
+int dStrncmp(const char *str1, const char *str2, dsize_t len)
+{
+   return strncmp(str1, str2, len);   
+}  
+ 
+int dStrnicmp(const char *str1, const char *str2, dsize_t len)
+{
+   S32 i;
+   char c1, c2;
+   for (i=0; i<len; i++)
+   {
+      c1 = tolower(*str1++);
+      c2 = tolower(*str2++);
+      if (c1 < c2) return -1;
+      if (c1 > c2) return 1;
+      if (!c1) return 0;
+     }
+   return 0;
+}   
+
+
+char* dStrcpy(char *dst, const char *src)
+{
+   return strcpy(dst,src);
+}   
+
+char* dStrncpy(char *dst, const char *src, dsize_t len)
+{
+   return strncpy(dst,src,len);
+}   
+
+dsize_t dStrlen(const char *str)
+{
+   return strlen(str);
+}   
+
+/*dsize_t dStrlenUTF8_fast(const UTF8 *str)
+{
+   // we do not run this through the operating system, because this method may be faster.
+   int c = 0;
+   for(; str; str = getNextUTF8Char(str))
+      c++;
+
+   return c;
+}
+*/
+/*dsize_t dStrlenUTF8(const UTF8 *str)
+{
+   CFStringRef cfstr;
+   U32         cfstrlen;
+   
+   if(!str)
+      return 0;
+      
+   cfstr = CFStringCreateWithCString( kCFAllocatorDefault, (char*)str, kCFStringEncodingUTF8);
+   if(!cfstr)
+      return 0;
+   cfstrlen = CFStringGetLength(cfstr);
+   CFRelease(cfstr);
+   
+   return cfstrlen;
+
+}
+*/
+/*dsize_t dStrlen(const UTF16 *str)
+{
+   int i=0;
+   while(str[i] != 0x0000) i++;
+   
+   return i;
+
+   // slower than just counting wchars, but makes sure surrogate pairs are dealt with correctly.
+   CFStringRef cfstr;
+   U32         cfstrlen;
+   
+   cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (char*)str, kCFStringEncodingUnicode);
+   cfstrlen = CFStringGetLength(cfstr);
+   CFRelease(cfstr);
+   
+   return cfstrlen;
+}
+*/
+
+char* dStrupr(char *str)
+{
+   char* saveStr = str;
+   while (*str)
+   {
+      *str = toupper(*str);
+      str++;
+   }
+   return saveStr;
+}   
+
+
+char* dStrlwr(char *str)
+{
+   char* saveStr = str;
+   while (*str)
+   {
+      *str = tolower(*str);
+      str++;
+   }
+   return saveStr;
+}   
+
+
+char* dStrchr(char *str, int c)
+{
+   return strchr(str,c);
+}   
+
+
+const char* dStrchr(const char *str, int c)
+{
+   return strchr(str,c);
+}   
+
+const char* dStrrchr(const char *str, int c)
+{
+   return strrchr(str,c);
+}   
+
+
+char* dStrrchr(char *str, int c)
+{
+   return strrchr(str,c);
+}   
+
+dsize_t dStrspn(const char *str, const char *set)
+{
+   return(strspn(str, set));
+}
+
+dsize_t dStrcspn(const char *str, const char *set)
+{
+   return strcspn(str, set);
+}   
+
+
+char* dStrstr(char *str1, char *str2)
+{
+   return strstr(str1,str2);
+}
+
+char* dStrstr(const char *str1, const char *str2)
+{
+   return strstr(str1,str2);
+}   
+
+char* dStrtok(char *str, const char *sep)
+{
+   return strtok(str, sep);
+}
+
+
+int dAtoi(const char *str)
+{
+   return atoi(str);   
+}  
+
+ 
+float dAtof(const char *str)
+{
+   return atof(str);   
+}   
+
+bool dAtob(const char *str)
+{
+   return !dStricmp(str, "true") || !dStricmp(str, "1") || (0!=dAtoi(str));
+}   
+
+bool dIsalnum(const char c)
+{
+   return isalnum(c);
+}
+
+bool dIsalpha(const char c)
+{
+   return(isalpha(c));
+}
+
+bool dIsspace(const char c)
+{
+   return(isspace(c));
+}
+
+bool dIsdigit(const char c)
+{
+   return(isdigit(c));
+}
+
+void dPrintf(const char *format, ...)
+{
+   va_list args;
+   va_start(args, format);
+   vprintf(format, args);
+}   
+
+int dVprintf(const char *format, void *arglist)
+{
+   S32 len = vprintf(format, (char*)arglist);
+
+   // to-do
+   // The intended behavior is to zero-terminate and not allow the overflow
+   return (len);
+}   
+
+int dSprintf(char *buffer, dsize_t /*bufferSize*/, const char *format, ...)
+{
+   va_list args;
+   va_start(args, format);
+   S32 len = vsprintf(buffer, format, args);
+
+#warning "need to added zero-term + overflow handling"
+   // to-do
+   // The intended behavior is to zero-terminate and not allow the overflow
+   return (len);
+}   
+
+
+int dVsprintf(char *buffer, dsize_t /*bufferSize*/, const char *format, void *arglist)
+{
+   S32 len = vsprintf(buffer, format, (char*)arglist);
+
+#warning "need to added zero-term + overflow handling"
+   // to-do
+   // The intended behavior is to zero-terminate and not allow the overflow
+   return (len);
+}   
+
+
+int dSscanf(const char *buffer, const char *format, ...)
+{
+   va_list args;
+   va_start(args, format);
+//   return __vsscanf(buffer, format, args);   
+   return vsscanf(buffer, format, args);   
+}   
+
+int dFflushStdout()
+{
+   return fflush(stdout);
+}
+
+int dFflushStderr()
+{
+   return fflush(stderr);
+}
+
+void dQsort(void *base, U32 nelem, U32 width, int (QSORT_CALLBACK *fcmp)(const void *, const void *))
+{
+   qsort(base, nelem, width, fcmp);
+}   
+
+
+//---------------------------------------------------------------------------
+// Mac Strinng conversion routines
+U8* str2p(const char *str)
+{
+   static U8 buffer[256];
+   str2p(str, buffer);
+   return buffer;
+}
+
+
+U8* str2p(const char *str, U8 *p)
+{
+   AssertFatal(dStrlen(str) <= 255, "str2p:: Max Pascal String length exceeded (max=255).");
+   U8 *dst = p+1;
+   U8 *src = (U8*)str;
+   *p = 0;
+   while(*src != '\0')
+   {
+      *dst++ = *src++;
+      (*p) += 1;
+   }
+   return p;
+}
+
+
+char* p2str(U8 *p)
+{
+   static char buffer[256];
+   p2str(p, buffer);
+   return buffer;
+}
+
+
+char* p2str(U8 *p, char *dst_str)
+{
+   U8 len = *p++;
+   char *src = (char*)p;
+   char *dst = dst_str;
+   while (len--)
+   {
+      *dst++ = *src++;
+   }
+   *dst = '\0';
+   return dst_str;
+}
+
+//------------------------------------------------------------------------------
+// Unicode string conversions
+//------------------------------------------------------------------------------
+/*UTF8 * convertUTF16toUTF8(const UTF16 *string, UTF8 *buffer, U32 bufsize)
+{
+   PROFILE_START(convertUTF16toUTF8);
+   // use a CFString to convert the unicode string.
+   // CFStrings use a UTF16 based backing store.
+   // the last kCFAllocatorNull parameter is a deallocator for the string passed in.
+   //  we pass the Null allocator so that string will not be klobbered.
+   // note: on 10.4+, another constant, kCFStringEncodingUTF16 is available, and
+   //  it is an alias for kCFStringEncodingUnicode.
+   //  see: http://developer.apple.com/documentation/CoreFoundation/Reference/CFStringRef/Reference/chapter_2.2_section_1.html 
+   bool        ok;
+   CFStringRef cfstr;
+   
+   U32 len = dStrlen(string);
+   cfstr = CFStringCreateWithCharacters( kCFAllocatorDefault, string, len);
+   //cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (const char*)string, kCFStringEncodingUnicode);
+   AssertFatal(cfstr != NULL, "Unicode string conversion failed - couldn't make the CFString!");
+
+   ok = CFStringGetCString( cfstr, (char*)buffer, bufsize, kCFStringEncodingUTF8);
+   CFRelease(cfstr);
+   
+   AssertWarn( ok, "Unicode string conversion failed in convertUTF16toUTF8()");
+   if( !ok ) {
+      PROFILE_END();
+      return NULL;
+   }
+      
+   buffer[bufsize-1] = 0x00;
+   
+   PROFILE_END();
+   return buffer;
+}
+
+
+//------------------------------------------------------------------------------
+UTF16 * convertUTF8toUTF16(const UTF8 *string, UTF16 *buffer, U32 bufsize)
+{
+   // see above notes in convertUTF16toUTF8() for an explanation of the following.
+   // what we do here is exactly the same process as above, but in reverse.
+   PROFILE_START(convertUTF8toUTF16);
+   bool        ok;
+   CFStringRef cfstr;   
+   if( !string || string[0] == '\0' )
+      goto returnNull;
+      
+   cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (char*)string, kCFStringEncodingUTF8);
+   if(!cfstr)
+      goto returnNull;
+   
+   ok = CFStringGetCString( cfstr, (char*)buffer, bufsize*sizeof(UTF16), kCFStringEncodingUnicode);
+   CFRelease(cfstr);
+   
+   AssertWarn( ok, "Unicode string conversion failed or buffer was too small in convertUTF8toUTF16()");
+   if( !ok )
+      goto returnNull;
+         
+   buffer[bufsize-1] = 0x000;
+
+   PROFILE_END();
+   return buffer;
+
+returnNull:
+   PROFILE_END();
+   return NULL;
+}
+*/