CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/CoreLib/hsUtils.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsUtils.h"
#if HS_BUILD_FOR_MAC
#include <Gestalt.h>
#endif
#if HS_BUILD_FOR_WIN32
extern "C" {
#endif
#include <stdio.h>
#include <stdarg.h>
#if HS_BUILD_FOR_WIN32
};
#endif
#if __MWERKS__
#include <ctype.h>
#endif
#if HS_BUILD_FOR_PS2
#include <ctype.h>
#include "eekernel.h"
#include "sifdev.h"
#endif

#if HS_BUILD_FOR_WIN32
#include <winsock2.h>
#include <windows.h>
#endif
#include "hsStlUtils.h"
#include "hsTemplates.h"


char * hsFormatStr(const char * fmt, ...)
{
	va_list args;
	va_start(args,fmt);
	char * result = hsFormatStrV(fmt,args);
	va_end(args);
	return result;
}

char * hsFormatStrV(const char * fmt, va_list args)
{
	std::string buf;
	xtl::formatv(buf,fmt,args);
	return hsStrcpy(buf.c_str());
}

static char hsStrBuf[100];

char *hsScalarToStr(hsScalar s)
{
#if !(HS_BUILD_FOR_REFERENCE)
	if (s == hsIntToScalar(hsScalarToInt(s)))
		sprintf(hsStrBuf, "%d", hsScalarToInt(s));
	else
	#if HS_CAN_USE_FLOAT
		sprintf(hsStrBuf, "%f", hsScalarToFloat(s));
	#else
		sprintf(hsStrBuf, "%d:%lu", hsFixedToInt(s), (UInt16)s);
	#endif
#endif
	return hsStrBuf;
}

bool hsMessageBox_SuppressPrompts = false;

int hsMessageBoxWithOwner(void * owner, const char message[], const char caption[], int kind, int icon)
{
	if (hsMessageBox_SuppressPrompts)
		return hsMBoxOk;

#if HS_BUILD_FOR_WIN32
	UInt32 flags = 0;

	if (kind == hsMessageBoxNormal)
		flags |= MB_OK;
	else if (kind == hsMessageBoxAbortRetyIgnore)
		flags |= MB_ABORTRETRYIGNORE;
	else if (kind == hsMessageBoxOkCancel)
		flags |= MB_OKCANCEL;
	else if (kind == hsMessageBoxRetryCancel)
		flags |= MB_RETRYCANCEL;
	else if (kind == hsMessageBoxYesNo)
		flags |= MB_YESNO;
	else if (kind == hsMessageBoxYesNoCancel)
		flags |= MB_YESNOCANCEL;
	else
		flags |= MB_OK;

	if (icon == hsMessageBoxIconError)
		flags |= MB_ICONERROR;
	else if (icon == hsMessageBoxIconQuestion)
		flags |= MB_ICONQUESTION;
	else if (icon == hsMessageBoxIconExclamation)
		flags |= MB_ICONEXCLAMATION;
	else if (icon == hsMessageBoxIconAsterisk)
		flags |= MB_ICONASTERISK;
	else
		flags |= MB_ICONERROR;

#ifdef CLIENT
	ErrorMinimizeAppWindow();
#endif
	int ans = MessageBox((HWND)owner, message, caption, flags);

	switch (ans)
	{
	case IDOK:			return hsMBoxOk;
	case IDCANCEL:		return hsMBoxCancel;
	case IDABORT:		return hsMBoxAbort;
	case IDRETRY:		return hsMBoxRetry;
	case IDIGNORE:		return hsMBoxIgnore;
	case IDYES:			return hsMBoxYes;
	case IDNO:			return hsMBoxNo;
	default:			return hsMBoxCancel;
	}

#endif
#if HS_BUILD_FOR_MACPPC
	DebugStr(message);
#endif
#if HS_BUILD_FOR_PS2
	printf("Cap:%s Message:%s\n",caption, message);
#endif
}

int hsMessageBoxWithOwner(void * owner, const wchar_t message[], const wchar_t caption[], int kind, int icon)
{
	if (hsMessageBox_SuppressPrompts)
		return hsMBoxOk;

#if HS_BUILD_FOR_WIN32
	UInt32 flags = 0;
	
	if (kind == hsMessageBoxNormal)
		flags |= MB_OK;
	else if (kind == hsMessageBoxAbortRetyIgnore)
		flags |= MB_ABORTRETRYIGNORE;
	else if (kind == hsMessageBoxOkCancel)
		flags |= MB_OKCANCEL;
	else if (kind == hsMessageBoxRetryCancel)
		flags |= MB_RETRYCANCEL;
	else if (kind == hsMessageBoxYesNo)
		flags |= MB_YESNO;
	else if (kind == hsMessageBoxYesNoCancel)
		flags |= MB_YESNOCANCEL;
	else
		flags |= MB_OK;
	
	if (icon == hsMessageBoxIconError)
		flags |= MB_ICONERROR;
	else if (icon == hsMessageBoxIconQuestion)
		flags |= MB_ICONQUESTION;
	else if (icon == hsMessageBoxIconExclamation)
		flags |= MB_ICONEXCLAMATION;
	else if (icon == hsMessageBoxIconAsterisk)
		flags |= MB_ICONASTERISK;
	else
		flags |= MB_ICONERROR;
	
#ifdef CLIENT
	ErrorMinimizeAppWindow();
#endif
	int ans = MessageBoxW((HWND)owner, message, caption, flags);
	
	switch (ans)
	{
	case IDOK:			return hsMBoxOk;
	case IDCANCEL:		return hsMBoxCancel;
	case IDABORT:		return hsMBoxAbort;
	case IDRETRY:		return hsMBoxRetry;
	case IDIGNORE:		return hsMBoxIgnore;
	case IDYES:			return hsMBoxYes;
	case IDNO:			return hsMBoxNo;
	default:			return hsMBoxCancel;
	}
	
#endif
#if HS_BUILD_FOR_MACPPC
	DebugStr(message);
#endif
#if HS_BUILD_FOR_PS2
	printf("Cap:%s Message:%s\n",caption, message);
#endif
}

int hsMessageBox(const char message[], const char caption[], int kind, int icon)
{
#if HS_BUILD_FOR_WIN32
	return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/,message,caption,kind,icon);
#else
	return hsMessageBoxWithOwner(nil,message,caption,kind,icon);
#endif
}

int hsMessageBox(const wchar_t message[], const wchar_t caption[], int kind, int icon)
{
#if HS_BUILD_FOR_WIN32
	return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/,message,caption,kind,icon);
#else
	return hsMessageBoxWithOwner(nil,message,caption,kind,icon);
#endif
}


/* Generic psuedo RNG used in ANSI C. */ 
static unsigned long SEED = 1;
int hsRand()
{
	register int temp;
	SEED = SEED * 1103515245 + 12345;
	temp = (int)((SEED/65536)&32767);
	return (temp);
}

void hsRandSeed(int seed)
{
	SEED = seed;
}
/**************************************/
int hsStrlen(const char src[])
{
	if (src==nil)
		return 0;

	int i = 0;
	while (src[i])
		i++;
	return i;
}

char* hsStrcpy(char dst[], const char src[])
{
	if (src)
	{
		if (dst == nil)
		{
			int	count = hsStrlen(src);
			dst = (char *)ALLOC(count + 1);
			memcpy(dst, src, count);
			dst[count] = 0;
			return dst;
		}

		Int32 i;
		for (i = 0; src[i] != 0; i++)
			dst[i] = src[i];
		dst[i] = 0;
	}

	return dst;
}

hsBool hsStrEQ(const char s1[], const char s2[])
{
	if (s1 && s2)
	{
		while (*s1)
			if(*s1++ != *s2++)
				return false;
		return *s2 == 0;
	}

	return (!s1 && !s2);
}

hsBool hsStrCaseEQ(const char* s1, const char* s2)
{
	if (s1 && s2)
	{
		while (*s1)
			if(tolower(*s1++) != tolower(*s2++))
				return false;
		return *s2 == 0;
	}

	return (!s1 && !s2);
}

void hsStrcat(char dst[], const char src[])
{
	if (src && dst)
	{
		dst += hsStrlen(dst);
		while(*src)
			*dst++ = *src++;
		*dst = 0;
	}
}

void hsStrLower(char *s)
{
	if (s)
	{
		int i;
		for (i = 0; i < hsStrlen(s); i++)
			s[i] = tolower(s[i]); 
	}
}

char* hsP2CString(const UInt8 pstring[], char cstring[])
{
	char*	     cstr = cstring;
	const UInt8* stop = &pstring[1] + pstring[0];
	
	pstring += 1;	//	skip length byte
	while (pstring < stop)
		*cstr++ = *pstring++;
	*cstr = 0;
	return cstring;
}

UInt8* hsC2PString(const char cstring[], UInt8 pstring[])
{
	int	i;

	for (i = 1; *cstring; i++)
		pstring[i] = *cstring++;
	pstring[0] = i - 1;
	return pstring;
}

//// IStringToWString /////////////////////////////////////////////////////////
// Converts a char * string to a wchar_t * string

wchar_t	*hsStringToWString( const char *str )
{
	// convert the char string to a wchar_t string
	int len = strlen(str);
	wchar_t *wideString = TRACKED_NEW wchar_t[len+1];
	for (int i=0; i<len; i++)
		wideString[i] = btowc(str[i]);
	wideString[len] = L'\0';
	return wideString;
}

void	hsStringToWString( wchar_t *dst, const char *src )
{
	if (dst)
		delete [] dst;
	dst = hsStringToWString(src);
}

//// IWStringToString /////////////////////////////////////////////////////////
// Converts a wchar_t * string to a char * string

char	*hsWStringToString( const wchar_t *str )
{
	// convert the wchar_t string to a char string
	int len = wcslen(str);
	char *sStr = TRACKED_NEW char[len+1];

	int i;
	for (i = 0; i < len; i++)
	{
		char temp = wctob(str[i]);
		if (temp == WEOF)
		{
			sStr[i] = '\0';
			i = len;
		}
		else
			sStr[i] = temp;
	}
	sStr[len] = '\0';

	return sStr;
}

void	hsWStringToString( char *dst, const wchar_t *src )
{
	if (dst)
		delete [] dst;
	dst = hsWStringToString(src);
}

void hsCPathToMacPath(char* dst, char* fname)
{
	int i;
	
	int 	offset = 0;
	hsBool 	prefix = 1; 	// Assume its a relative path.
	
	// KLUDGE: this determines whether a PC path is 
	// relative or absolute. True if relative, therefore
	// we prefix the pathname with a colon.
	
	hsStrcpy(dst, "");

	if(strstr(fname, ":"))
	{
		prefix = 0;
	}
	else if(strstr(fname, "\\\\"))
	{
		prefix = 0;
		offset = 2; 		// copy fname from 2-bytes in. This removes 
							// the first two chars...
	}

	if(prefix)
	{
		hsStrcpy(dst, ":");
	}
	
	hsStrcat(dst, &fname[offset]);
	
	// No more slashes? We're done. (Optimization? Not really I guess.)
	if(!strstr(dst, "\\") && !strstr(dst, "/")) return; 
	
	for(i =0; i < hsStrlen(dst); i++)
	{
		if(dst[i] == '\\' || dst[i] == '/')
		{
			dst[i] = ':';
		}
	}
}

int hsRemove(const char * fname)
{
#if HS_BUILD_FOR_MACPPC
	char buf[500];
	hsStrcpy(buf,":");
	hsStrcat(buf,fname);
	int i;
	for(i =0; i < hsStrlen(buf); i++)
		if(buf[i] == '\\')
			buf[i] = ':';
	return remove(buf);
#endif
	return remove(fname);
	
}

UInt32 hsPhysicalMemory()
{
#define HS_ONE_MEGABYTE 1048576 // 1024 * 1024

#if HS_BUILD_FOR_WIN32
	MEMORYSTATUS ms;
	GlobalMemoryStatus(&ms);
	return (ms.dwTotalPhys / HS_ONE_MEGABYTE);
#elif HS_BUILD_FOR_MAC
	// Silver, figure out the physical memory here (in MB)	
	OSErr err;
	SInt32 TotPhysicalRAM;
	err = Gestalt(gestaltPhysicalRAMSize, &TotPhysicalRAM);
	return (TotPhysicalRAM / HS_ONE_MEGABYTE);
#endif
}

MemSpec hsMemorySpec()
{
	UInt32 mem = hsPhysicalMemory();

	// Currently adding a little margin of error here
	// due to the fact that Windows doesn't seem to
	// be totally accurate in it's calculations.
	if (mem < 127)
		return kBlows;
	else if (mem < 255)
		return kAcceptable;
	else
		return kOptimal;
}

#if HS_BUILD_FOR_MAC
FILE *hsFopen(const char *fname, const char *mode)
{
	char buf[500];
#if 0
	FILE *f;

	hsStrcpy(buf,":");
	hsStrcat(buf,fname);
	int i;
	for(i =0; i < hsStrlen(buf); i++)
		if(buf[i] == '\\')
			buf[i] = ':';
	
#endif
	hsCPathToMacPath(buf, (char*)fname);
	return fopen(buf,mode);
}

#endif
#if HS_BUILD_FOR_PS2
int hsPS2Open(const char name[], const char mode[])
{
  char buf[500];
  int newMode;
  int i;
  hsStrcpy(buf,"sim:");
//hsStrcpy(buf,"");
  hsStrcat(buf,name);
  for(i =0; i < hsStrlen(buf); i++)
	if(buf[i] == '\\')
		buf[i] = '/';
  printf("Opening File %s\n",buf);
  if(mode[0] == 'r')
    newMode = SCE_RDONLY;
  else if(mode[0] == 'w')
    newMode = SCE_WRONLY|SCE_CREAT;
  else
    hsAssert(0,"Bad mode in hsPS2Open\n");

  printf("Opening File %s mode =%d\n",buf,newMode);
   return  sceOpen(buf,newMode);
}

void hsPS2Close( int file )
{
	if( file != -1 )
		sceClose( file );
}

//FILE *hsFopen(const char *fname, const char *mode)
//{	
//	FILE *f;
//	char buf[500];
//	char newMode[10];
//	hsStrcpy(buf,"sim:");
//	//hsStrcpy(buf,"");
//	hsStrcat(buf,fname);
//	int i;
//	for(i =0; i < hsStrlen(buf); i++)
//		if(buf[i] == '\\')
//			buf[i] = '/';
//	printf("Opening File %s\n",buf);
//	if(!strcmp("rt",mode))
//	  {
//	    strcpy(newMode, "r");
//	  }
//	else
//	  strcpy(newMode, mode);
//
//	printf("Opening File %s mode =%s\n",buf,newMode);
//	f= fopen(buf,newMode);
//	if(f)
//		return f;
//	else
//		return nil;
//}
#endif

// Compare lexigraphically two strings

#if !(HS_BUILD_FOR_WIN32 || HS_BUILD_FOR_UNIX)

int hsStrcasecmp(const char *s1, const char *s2)
{
	if (s1 && s2)
	{
		char c1, c2;
		while (1)
		{
    		c1 = tolower(*s1++);
    		c2 = tolower(*s2++);
			if (c1 < c2) return -1;
			if (c1 > c2) return 1;
			if (c1 == '\0') return 0;
		}
	}
	return !s1 ? -1 : 1;
}

// Compare lexigraphically two strings up to a max length

int hsStrncasecmp(const char *s1, const char *s2, int n)
{
	if (s1 && s2)
	{
		int i;
		char c1, c2;
		for (i=0; i<n; i++)
		{
			c1 = tolower(*s1++);
			c2 = tolower(*s2++);
			if (c1 < c2) return -1;
			if (c1 > c2) return 1;
			if (!c1) return 0;
		}
		return 0;
	}
	return !s1 ? -1 : 1;
}
#endif

//
// Microsoft SAMPLE CODE
// returns array of allocated version info strings or nil
//
char** DisplaySystemVersion()
{
#if HS_BUILD_FOR_WIN32
#ifndef VER_SUITE_PERSONAL
#define VER_SUITE_PERSONAL 0x200
#endif
	hsTArray<char*> versionStrs;
	OSVERSIONINFOEX osvi;
	BOOL bOsVersionInfoEx;
	
	// Try calling GetVersionEx using the OSVERSIONINFOEX structure.
	//
	// If that fails, try using the OSVERSIONINFO structure.
	
	ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
	
	if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
	{
		// If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
		
		osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
		if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
			return FALSE;
	}
	
	switch (osvi.dwPlatformId)
	{
	case VER_PLATFORM_WIN32_NT:
		
		// Test for the product.
		
		if ( osvi.dwMajorVersion <= 4 )
            versionStrs.Append(hsStrcpy("Microsoft Windows NT "));
		
		if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
            versionStrs.Append(hsStrcpy ("Microsoft Windows 2000 "));
		
		if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
            versionStrs.Append(hsStrcpy ("Microsoft Windows XP "));
		
		// Test for product type.
		
		if( bOsVersionInfoEx )
		{
            if ( osvi.wProductType == VER_NT_WORKSTATION )
            {
				if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
					versionStrs.Append(hsStrcpy ( "Personal " ));
				else
					versionStrs.Append(hsStrcpy ( "Professional " ));
            }
			
            else if ( osvi.wProductType == VER_NT_SERVER )
            {
				if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
					versionStrs.Append(hsStrcpy ( "DataCenter Server " ));
				else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
					versionStrs.Append(hsStrcpy ( "Advanced Server " ));
				else
					versionStrs.Append(hsStrcpy ( "Server " ));
            }
		}
		else
		{
            HKEY hKey;
            char szProductType[80];
            DWORD dwBufLen;
			
            RegOpenKeyEx( HKEY_LOCAL_MACHINE,
				"SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
				0, KEY_QUERY_VALUE, &hKey );
            RegQueryValueEx( hKey, "ProductType", NULL, NULL,
				(LPBYTE) szProductType, &dwBufLen);
            RegCloseKey( hKey );
            if ( lstrcmpi( "WINNT", szProductType) == 0 )
				versionStrs.Append(hsStrcpy( "Professional " ));
            if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
				versionStrs.Append(hsStrcpy( "Server " ));
            if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
				versionStrs.Append(hsStrcpy( "Advanced Server " ));
		}
		
		// Display version, service pack (if any), and build number.
		
		if ( osvi.dwMajorVersion <= 4 )
		{
            versionStrs.Append(hsStrcpy (xtl::format("version %d.%d %s (Build %d)\n",
				osvi.dwMajorVersion,
				osvi.dwMinorVersion,
				osvi.szCSDVersion,
				osvi.dwBuildNumber & 0xFFFF).c_str()));
		}
		else
		{ 
            versionStrs.Append(hsStrcpy (xtl::format("%s (Build %d)\n",
				osvi.szCSDVersion,
				osvi.dwBuildNumber & 0xFFFF).c_str()));
		}
		break;
		
	case VER_PLATFORM_WIN32_WINDOWS:
		
		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
		{
			versionStrs.Append(hsStrcpy ("Microsoft Windows 95 "));
			if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
                versionStrs.Append(hsStrcpy("OSR2 " ));
		} 
		
		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
		{
			versionStrs.Append(hsStrcpy ("Microsoft Windows 98 "));
			if ( osvi.szCSDVersion[1] == 'A' )
                versionStrs.Append(hsStrcpy("SE " ));
		} 
		
		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
		{
			versionStrs.Append(hsStrcpy ("Microsoft Windows Me "));
		} 
		break;
		
	case VER_PLATFORM_WIN32s:
		
		versionStrs.Append(hsStrcpy ("Microsoft Win32s "));
		break;
	}
	
	versionStrs.Append(nil);	// terminator
	
	return versionStrs.DetachArray();
#else
	return nil;
#endif
}