AS OF SVN REV. 5901, WE ARE NOW USING TRUNK. ALL UNTESTED BUGFIXES/FEATURES GO INTO TRUNK.

IF YOU HAVE A WORKING AND TESTED BUGFIX PUT IT INTO STABLE AS WELL AS TRUNK.  EVERYTHING ELSE
GOES INTO TRUNK AND WILL BE MERGED INTO STABLE BY VALARIS AND WIZPUTER. -- VALARIS


git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@5094 54d463be-8e91-2dee-dedb-b68131a5f0ec

1 files changed, 384 insertions, 0 deletions

diff --git a/src/common/utils.c b/src/common/utils.c
new file mode 100644
index 000000000..57dc1f480
--- /dev/null
+++ b/src/common/utils.c
@@ -0,0 +1,384 @@
+// Copyright (c) Athena Dev Teams - Licensed under GNU GPL

+// For more information, see LICENCE in the main folder

+

+#include <stdio.h>

+#include <stdarg.h>

+#include <stdlib.h>

+#include <string.h>

+

+#ifdef WIN32

+	#include <windows.h>

+	#define PATHSEP '\\'

+#else

+	#include <unistd.h>

+	#include <dirent.h>

+	#include <sys/stat.h>

+	#define PATHSEP '/'

+#endif

+

+#include "utils.h"

+#include "../common/mmo.h"

+#include "../common/malloc.h"

+#include "../common/showmsg.h"

+

+void dump(unsigned char *buffer, int num)

+{

+   int     icnt,jcnt;

+

+   printf("         Hex                                                  ASCII\n");

+   printf("         -----------------------------------------------      ----------------");

+

+   for (icnt=0;icnt<num;icnt+=16) {

+	printf("\n%p ",&buffer[icnt]);

+    for (jcnt=icnt;jcnt<icnt+16;++jcnt) {

+	    if (jcnt < num) {

+              printf("%02hX ",buffer[jcnt]);

+		}  else

+              printf("   ");

+    }

+

+    printf("  |  ");

+

+	for (jcnt=icnt;jcnt<icnt+16;++jcnt) {

+        if (jcnt < num) {

+            if (buffer[jcnt] > 31 && buffer[jcnt] < 127)

+                   printf("%c",buffer[jcnt]);

+               else

+                   printf(".");

+           }  else

+               printf(" ");

+       }

+   }

+   printf("\n");

+}

+

+//NOTE: There is no need to use this function as the standard sqrt is plenty fast as it is. [Skotlex]

+int newt_sqrt(int input)

+{

+	int new_value, value = input/2, count = 0;

+	if (!value) //Division by zero fix, pointed out by Shinomori. [Skotlex]

+		return input;

+	do

+	{

+		new_value = (value + input/value)>>1;

+		if (abs(value - new_value) <= 1)

+			return new_value;

+		value = new_value;

+	}

+	while (count++ < 25);

+	return new_value;

+}

+

+#if defined(_WIN32) && !defined(MINGW)

+char *rindex(char *str, char c)

+{

+        char *sptr;

+

+        sptr = str;

+        while(*sptr)

+                ++sptr;

+        if (c == '\0')

+                return(sptr);

+        while(str != sptr)

+                if (*sptr-- == c)

+                        return(++sptr);

+        return(NULL);

+}

+

+int strcasecmp(const char *arg1, const char *arg2)

+{

+  int chk, i;

+

+  if (arg1 == NULL || arg2 == NULL) {

+    ShowError("strcasecmp: received a NULL pointer, %p or %p.\n", arg1, arg2);

+    return (0);

+  }

+

+  for (i = 0; arg1[i] || arg2[i]; i++)

+    if ((chk = LOWER(arg1[i]) - LOWER(arg2[i])) != 0)

+      return (chk);	/* not equal */

+

+  return (0);

+}

+

+int strncasecmp(const char *arg1, const char *arg2, int n)

+{

+  int chk, i;

+

+  if (arg1 == NULL || arg2 == NULL) {

+    ShowError("strncasecmp(): received a NULL pointer, %p or %p.\n", arg1, arg2);

+    return (0);

+  }

+

+  for (i = 0; (arg1[i] || arg2[i]) && (n > 0); i++, n--)

+    if ((chk = LOWER(arg1[i]) - LOWER(arg2[i])) != 0)

+      return (chk);	/* not equal */

+

+  return (0);

+}

+

+void str_upper(char *name)

+{

+

+  int len = (int)strlen(name);

+  while (len--) {

+	if (*name >= 'a' && *name <= 'z')

+    	*name -= ('a' - 'A');

+     name++;

+  }

+}

+

+void str_lower(char *name)

+{

+  int len = (int)strlen(name);

+

+  while (len--) {

+	if (*name >= 'A' && *name <= 'Z')

+    	*name += ('a' - 'A');

+    name++;

+  }

+}

+

+#endif

+

+// Allocate a StringBuf  [MouseJstr]

+struct StringBuf * StringBuf_Malloc() 

+{

+	struct StringBuf * ret = (struct StringBuf *) aMallocA(sizeof(struct StringBuf));

+	StringBuf_Init(ret);

+	return ret;

+}

+

+// Initialize a previously allocated StringBuf [MouseJstr]

+void StringBuf_Init(struct StringBuf * sbuf)  {

+	sbuf->max_ = 1024;

+	sbuf->ptr_ = sbuf->buf_ = (char *) aMallocA(sbuf->max_ + 1);

+}

+

+// printf into a StringBuf, moving the pointer [MouseJstr]

+int StringBuf_Printf(struct StringBuf *sbuf,const char *fmt,...) 

+{

+	va_list ap;

+        int n, size, off;

+

+	while (1) {

+		/* Try to print in the allocated space. */

+		va_start(ap, fmt);

+		size = sbuf->max_ - (sbuf->ptr_ - sbuf->buf_);

+		n = vsnprintf (sbuf->ptr_, size, fmt, ap);

+		va_end(ap);

+		/* If that worked, return the length. */

+		if (n > -1 && n < size) {

+			sbuf->ptr_ += n;

+			return (int)(sbuf->ptr_ - sbuf->buf_);

+		}

+		/* Else try again with more space. */

+		sbuf->max_ *= 2; // twice the old size

+		off = (int)(sbuf->ptr_ - sbuf->buf_);

+		sbuf->buf_ = (char *) aRealloc(sbuf->buf_, sbuf->max_ + 1);

+		sbuf->ptr_ = sbuf->buf_ + off;

+	}

+}

+

+// Append buf2 onto the end of buf1 [MouseJstr]

+int StringBuf_Append(struct StringBuf *buf1,const struct StringBuf *buf2) 

+{

+	int buf1_avail = buf1->max_ - (buf1->ptr_ - buf1->buf_);

+	int size2 = (int)(buf2->ptr_ - buf2->buf_);

+

+	if (size2 >= buf1_avail)  {

+		int off = (int)(buf1->ptr_ - buf1->buf_);

+		buf1->max_ += size2;

+		buf1->buf_ = (char *) aRealloc(buf1->buf_, buf1->max_ + 1);

+		buf1->ptr_ = buf1->buf_ + off;

+	}

+

+	memcpy(buf1->ptr_, buf2->buf_, size2);

+	buf1->ptr_ += size2;

+	return (int)(buf1->ptr_ - buf1->buf_);

+}

+

+// Destroy a StringBuf [MouseJstr]

+void StringBuf_Destroy(struct StringBuf *sbuf) 

+{

+	aFree(sbuf->buf_);

+	sbuf->ptr_ = sbuf->buf_ = 0;

+}

+

+// Free a StringBuf returned by StringBuf_Malloc [MouseJstr]

+void StringBuf_Free(struct StringBuf *sbuf) 

+{

+	StringBuf_Destroy(sbuf);

+	aFree(sbuf);

+}

+

+// Return the built string from the StringBuf [MouseJstr]

+char * StringBuf_Value(struct StringBuf *sbuf) 

+{

+	*sbuf->ptr_ = '\0';

+	return sbuf->buf_;

+}

+

+#ifdef WIN32

+

+char* checkpath(char *path, const char *srcpath)

+{	// just make sure the char*path is not const

+	char *p=path;

+	if(NULL!=path && NULL!=srcpath)

+	while(*srcpath) {

+		if (*srcpath=='/') {

+			*p++ = '\\';

+			srcpath++;

+		}

+		else

+			*p++ = *srcpath++;

+	}

+	*p = *srcpath; //EOS

+	return path;

+}

+

+void findfile(const char *p, const char *pat, void (func)(const char*))

+{	

+	WIN32_FIND_DATA FindFileData;

+	HANDLE hFind;

+	char tmppath[MAX_PATH+1];

+	

+	const char *path    = (p  ==NULL)? "." : p;

+	const char *pattern = (pat==NULL)? "" : pat;

+	

+	checkpath(tmppath,path);

+	if( PATHSEP != tmppath[strlen(tmppath)-1])

+		strcat(tmppath, "\\*");

+	else

+		strcat(tmppath, "*");

+	

+	hFind = FindFirstFile(tmppath, &FindFileData);

+	if (hFind != INVALID_HANDLE_VALUE)

+	{

+		do

+		{

+			if (strcmp(FindFileData.cFileName, ".") == 0)

+				continue;

+			if (strcmp(FindFileData.cFileName, "..") == 0)

+				continue;

+

+			sprintf(tmppath,"%s%c%s",path,PATHSEP,FindFileData.cFileName);

+

+			if (FindFileData.cFileName && strstr(FindFileData.cFileName, pattern)) {

+				func( tmppath );

+			}

+

+

+			if( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )

+			{

+				findfile(tmppath, pat, func);

+			}

+		}while (FindNextFile(hFind, &FindFileData) != 0);

+		FindClose(hFind);

+   }

+   return;

+}

+#else

+

+#define MAX_DIR_PATH 2048

+

+char* checkpath(char *path, const char*srcpath)

+{	// just make sure the char*path is not const

+	char *p=path;

+	if(NULL!=path && NULL!=srcpath)

+	while(*srcpath) {

+		if (*srcpath=='\\') {

+			*p++ = '/';

+			srcpath++;

+		}

+		else

+			*p++ = *srcpath++;

+	}

+	*p = *srcpath; //EOS

+	return path;

+}

+

+void findfile(const char *p, const char *pat, void (func)(const char*))

+{	

+	DIR* dir;					// pointer to the scanned directory.

+	struct dirent* entry;		// pointer to one directory entry.

+	struct stat dir_stat;       // used by stat().

+	char tmppath[MAX_DIR_PATH+1];

+	char path[MAX_DIR_PATH+1]= ".";

+	const char *pattern = (pat==NULL)? "" : pat;

+	if(p!=NULL) strcpy(path,p);

+

+	// open the directory for reading

+	dir = opendir( checkpath(path, path) );

+	if (!dir) {

+		ShowError("Cannot read directory '%s'\n", path);

+		return;

+	}

+

+	// scan the directory, traversing each sub-directory

+	// matching the pattern for each file name.

+	while ((entry = readdir(dir))) {

+		// skip the "." and ".." entries.

+		if (strcmp(entry->d_name, ".") == 0)

+			continue;

+		if (strcmp(entry->d_name, "..") == 0)

+			continue;

+

+		sprintf(tmppath,"%s%c%s",path, PATHSEP, entry->d_name);

+

+		// check if the pattern matchs.

+		if (entry->d_name && strstr(entry->d_name, pattern)) {

+			func( tmppath );

+		}

+		// check if it is a directory.

+		if (stat(tmppath, &dir_stat) == -1) {

+			ShowError("stat error %s\n': ", tmppath);

+			continue;

+		}

+		// is this a directory?

+		if (S_ISDIR(dir_stat.st_mode)) {

+			// decent recursivly

+			findfile(tmppath, pat, func);

+		}

+	}//end while

+}

+#endif

+

+unsigned char GetByte(unsigned long val, size_t num)

+{

+	switch(num)

+	{

+	case 0:

+		return (unsigned char)((val & 0x000000FF)      );

+	case 1:

+		return (unsigned char)((val & 0x0000FF00)>>0x08);

+	case 2:

+		return (unsigned char)((val & 0x00FF0000)>>0x10);

+	case 3:

+		return (unsigned char)((val & 0xFF000000)>>0x18);

+	default:

+		return 0;	//better throw something here

+	}

+}

+unsigned short GetWord(unsigned long val, size_t num)

+{

+	switch(num)

+	{

+	case 0:

+		return (unsigned short)((val & 0x0000FFFF)      );

+	case 1:

+		return (unsigned short)((val & 0xFFFF0000)>>0x10);

+	default:

+		return 0;	//better throw something here

+	}

+}

+unsigned short MakeWord(unsigned char byte0, unsigned char byte1)

+{

+	return byte0 | (byte1<<0x08);

+}

+unsigned long MakeDWord(unsigned short word0, unsigned short word1)

+{

+	return 	  ((unsigned long)word0)

+			| ((unsigned long)word1<<0x10);

+}

+