Merge pull request #1 from HerculesWS/master

Update from original

1 files changed, 98 insertions, 78 deletions

diff --git a/src/common/strlib.c b/src/common/strlib.c
index 686b2e47d..592390770 100644
--- a/src/common/strlib.c
+++ b/src/common/strlib.c
@@ -2,16 +2,19 @@
 // See the LICENSE file
 // Portions Copyright (c) Athena Dev Teams
 
-#include "../common/cbasetypes.h"
-#include "../common/malloc.h"
-#include "../common/showmsg.h"
-#define STRLIB_C
+#define HERCULES_CORE
+
+#define H_STRLIB_C
 #include "strlib.h"
+#undef H_STRLIB_C
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <errno.h>
 
+#include "../common/cbasetypes.h"
+#include "../common/malloc.h"
+#include "../common/showmsg.h"
 
 #define J_MAX_MALLOC_SIZE 65535
 
@@ -144,15 +147,15 @@ char* trim(char* str)
 	if( start == end )
 		*str = '\0';// empty string
 	else
-	{// move string with nul terminator
+	{// move string with null-terminator
 		str[end] = '\0';
 		memmove(str,str+start,end-start+1);
 	}
 	return str;
 }
 
-// Converts one or more consecutive occurences of the delimiters into a single space
-// and removes such occurences from the beginning and end of string
+// Converts one or more consecutive occurrences of the delimiters into a single space
+// and removes such occurrences from the beginning and end of string
 // NOTE: make sure the string is not const!!
 char* normalize_name(char* str,const char* delims)
 {
@@ -189,7 +192,7 @@ char* normalize_name(char* str,const char* delims)
 	return str;
 }
 
-//stristr: Case insensitive version of strstr, code taken from 
+//stristr: Case insensitive version of strstr, code taken from
 //http://www.daniweb.com/code/snippet313.html, Dave Sinkula
 //
 const char* stristr(const char* haystack, const char* needle)
@@ -221,7 +224,7 @@ const char* stristr(const char* haystack, const char* needle)
 }
 
 #ifdef __WIN32
-char* _strtok_r(char *s1, const char *s2, char **lasts) {
+char* strtok_r_(char *s1, const char *s2, char **lasts) {
 	char *ret;
 
 	if (s1 == NULL)
@@ -240,16 +243,19 @@ char* _strtok_r(char *s1, const char *s2, char **lasts) {
 }
 #endif
 
+// TODO: The _MSC_VER check can probably be removed (we no longer support VS
+// versions <= 2003, do we?), but this implementation might be still necessary
+// for NetBSD 5.x and possibly some Solaris versions.
 #if !(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN)
 /* Find the length of STRING, but scan at most MAXLEN characters.
    If no '\0' terminator is found in that many characters, return MAXLEN.  */
-size_t strnlen (const char* string, size_t maxlen)
-{
-  const char* end = (const char*)memchr(string, '\0', maxlen);
-  return end ? (size_t) (end - string) : maxlen;
+size_t strnlen(const char* string, size_t maxlen) {
+	const char* end = (const char*)memchr(string, '\0', maxlen);
+	return end ? (size_t) (end - string) : maxlen;
 }
 #endif
 
+// TODO: This should probably be removed, I don't think we support MSVC++ 6.0 anymore.
 #if defined(WIN32) && defined(_MSC_VER) && _MSC_VER <= 1200
 uint64 strtoull(const char* str, char** endptr, int base)
 {
@@ -331,30 +337,39 @@ int e_mail_check(char* email)
 
 //--------------------------------------------------
 // Return numerical value of a switch configuration
-// on/off, english, français, deutsch, español
+// on/off, yes/no, true/false, number
 //--------------------------------------------------
-int config_switch(const char* str)
-{
-	if (strcmpi(str, "on") == 0 || strcmpi(str, "yes") == 0 || strcmpi(str, "oui") == 0 || strcmpi(str, "ja") == 0 || strcmpi(str, "si") == 0)
+int config_switch(const char* str) {
+	size_t len = strlen(str);
+	if ((len == 2 && strcmpi(str, "on") == 0)
+	 || (len == 3 && strcmpi(str, "yes") == 0)
+	 || (len == 4 && strcmpi(str, "true") == 0)
+	// || (len == 3 && strcmpi(str, "oui") == 0) // Uncomment and edit to add your own localized versions
+	)
 		return 1;
-	if (strcmpi(str, "off") == 0 || strcmpi(str, "no") == 0 || strcmpi(str, "non") == 0 || strcmpi(str, "nein") == 0)
+
+	if ((len == 3 && strcmpi(str, "off") == 0)
+	 || (len == 2 && strcmpi(str, "no") == 0)
+	 || (len == 5 && strcmpi(str, "false") == 0)
+	// || (len == 3 && strcmpi(str, "non") == 0) // Uncomment and edit to add your own localized versions
+	)
 		return 0;
 
 	return (int)strtol(str, NULL, 0);
 }
 
-/// strncpy that always nul-terminates the string
+/// strncpy that always null-terminates the string
 char* safestrncpy(char* dst, const char* src, size_t n)
 {
 	if( n > 0 )
 	{
 		char* d = dst;
 		const char* s = src;
-		d[--n] = '\0';/* nul-terminate string */
+		d[--n] = '\0';/* null-terminate string */
 		for( ; n > 0; --n )
 		{
 			if( (*d++ = *s++) == '\0' )
-			{/* nul-pad remaining bytes */
+			{/* null-pad remaining bytes */
 				while( --n > 0 )
 					*d++ = '\0';
 				break;
@@ -370,26 +385,25 @@ size_t safestrnlen(const char* string, size_t maxlen)
 	return ( string != NULL ) ? strnlen(string, maxlen) : 0;
 }
 
-/// Works like snprintf, but always nul-terminates the buffer.
-/// Returns the size of the string (without nul-terminator)
+/// Works like snprintf, but always null-terminates the buffer.
+/// Returns the size of the string (without null-terminator)
 /// or -1 if the buffer is too small.
 ///
 /// @param buf Target buffer
-/// @param sz Size of the buffer (including nul-terminator)
+/// @param sz Size of the buffer (including null-terminator)
 /// @param fmt Format string
 /// @param ... Format arguments
 /// @return The size of the string or -1 if the buffer is too small
-int safesnprintf(char* buf, size_t sz, const char* fmt, ...)
-{
+int safesnprintf(char *buf, size_t sz, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+int safesnprintf(char *buf, size_t sz, const char *fmt, ...) {
 	va_list ap;
 	int ret;
 
 	va_start(ap,fmt);
 	ret = vsnprintf(buf, sz, fmt, ap);
 	va_end(ap);
-	if( ret < 0 || (size_t)ret >= sz )
-	{// overflow
-		buf[sz-1] = '\0';// always nul-terminate
+	if (ret < 0 || (size_t)ret >= sz) { // overflow
+		buf[sz-1] = '\0';// always null-terminate
 		return -1;
 	}
 	return ret;
@@ -444,9 +458,9 @@ bool bin2hex(char* output, unsigned char* input, size_t count)
 /// Parses a single field in a delim-separated string.
 /// The delimiter after the field is skipped.
 ///
-/// @param sv Parse state
+/// @param svstate Parse state
 /// @return 1 if a field was parsed, 0 if already done, -1 on error.
-int sv_parse_next(struct s_svstate* sv)
+int sv_parse_next(struct s_svstate* svstate)
 {
 	enum {
 		START_OF_FIELD,
@@ -462,13 +476,13 @@ int sv_parse_next(struct s_svstate* sv)
 	char delim;
 	int i;
 
-	if( sv == NULL )
+	if( svstate == NULL )
 		return -1;// error
 
-	str = sv->str;
-	len = sv->len;
-	opt = sv->opt;
-	delim = sv->delim;
+	str = svstate->str;
+	len = svstate->len;
+	opt = svstate->opt;
+	delim = svstate->delim;
 
 	// check opt
 	if( delim == '\n' && (opt&(SV_TERMINATE_CRLF|SV_TERMINATE_LF)) )
@@ -482,9 +496,9 @@ int sv_parse_next(struct s_svstate* sv)
 		return -1;// error
 	}
 
-	if( sv->done || str == NULL )
+	if( svstate->done || str == NULL )
 	{
-		sv->done = true;
+		svstate->done = true;
 		return 0;// nothing to parse
 	}
 
@@ -495,10 +509,10 @@ int sv_parse_next(struct s_svstate* sv)
 	((opt&SV_TERMINATE_CR) && str[i] == '\r') || \
 	((opt&SV_TERMINATE_CRLF) && i+1 < len && str[i] == '\r' && str[i+1] == '\n') )
 #define IS_C_ESCAPE() ( (opt&SV_ESCAPE_C) && str[i] == '\\' )
-#define SET_FIELD_START() sv->start = i
-#define SET_FIELD_END() sv->end = i
+#define SET_FIELD_START() svstate->start = i
+#define SET_FIELD_END() svstate->end = i
 
-	i = sv->off;
+	i = svstate->off;
 	state = START_OF_FIELD;
 	while( state != END )
 	{
@@ -578,14 +592,14 @@ int sv_parse_next(struct s_svstate* sv)
 			else
 				++i;// CR or LF
 #endif
-			sv->done = true;
+			svstate->done = true;
 			state = END;
 			break;
 		}
 	}
 	if( IS_END() )
-		sv->done = true;
-	sv->off = i;
+		svstate->done = true;
+	svstate->off = i;
 
 #undef IS_END
 #undef IS_DELIM
@@ -603,47 +617,47 @@ int sv_parse_next(struct s_svstate* sv)
 /// out_pos[0] and out_pos[1] are the start and end of line.
 /// Other position pairs are the start and end of fields.
 /// Returns the number of fields found or -1 if an error occurs.
-/// 
+///
 /// out_pos can be NULL.
 /// If a line terminator is found, the end position is placed there.
-/// out_pos[2] and out_pos[3] for the first field, out_pos[4] and out_pos[5] 
+/// out_pos[2] and out_pos[3] for the first field, out_pos[4] and out_pos[5]
 /// for the seconds field and so on.
 /// Unfilled positions are set to -1.
-/// 
+///
 /// @param str String to parse
 /// @param len Length of the string
 /// @param startoff Where to start parsing
 /// @param delim Field delimiter
 /// @param out_pos Array of resulting positions
 /// @param npos Size of the pos array
-/// @param opt Options that determine the parsing behaviour
-/// @return Number of fields found in the string or -1 if an error occured
+/// @param opt Options that determine the parsing behavior
+/// @return Number of fields found in the string or -1 if an error occurred
 int sv_parse(const char* str, int len, int startoff, char delim, int* out_pos, int npos, enum e_svopt opt) {
-	struct s_svstate sv;
+	struct s_svstate svstate;
 	int count;
 
 	// initialize
 	if( out_pos == NULL ) npos = 0;
 	for( count = 0; count < npos; ++count )
 		out_pos[count] = -1;
-	sv.str = str;
-	sv.len = len;
-	sv.off = startoff;
-	sv.opt = opt;
-	sv.delim = delim;
-	sv.done = false;
+	svstate.str = str;
+	svstate.len = len;
+	svstate.off = startoff;
+	svstate.opt = opt;
+	svstate.delim = delim;
+	svstate.done = false;
 
 	// parse
 	count = 0;
 	if( npos > 0 ) out_pos[0] = startoff;
-	while( !sv.done ) {
+	while( !svstate.done ) {
 		++count;
-		if( sv_parse_next(&sv) <= 0 )
+		if( sv_parse_next(&svstate) <= 0 )
 			return -1;// error
-		if( npos > count*2 ) out_pos[count*2] = sv.start;
-		if( npos > count*2+1 ) out_pos[count*2+1] = sv.end;
+		if( npos > count*2 ) out_pos[count*2] = svstate.start;
+		if( npos > count*2+1 ) out_pos[count*2+1] = svstate.end;
 	}
-	if( npos > 1 ) out_pos[1] = sv.off;
+	if( npos > 1 ) out_pos[1] = svstate.off;
 	return count;
 }
 
@@ -651,21 +665,21 @@ int sv_parse(const char* str, int len, int startoff, char delim, int* out_pos, i
 /// WARNING: this function modifies the input string
 /// Starts splitting at startoff and fills the out_fields array.
 /// out_fields[0] is the start of the next line.
-/// Other entries are the start of fields (nul-teminated).
+/// Other entries are the start of fields (null-terminated).
 /// Returns the number of fields found or -1 if an error occurs.
-/// 
+///
 /// out_fields can be NULL.
-/// Fields that don't fit in out_fields are not nul-terminated.
+/// Fields that don't fit in out_fields are not null-terminated.
 /// Extra entries in out_fields are filled with the end of the last field (empty string).
-/// 
+///
 /// @param str String to parse
 /// @param len Length of the string
 /// @param startoff Where to start parsing
 /// @param delim Field delimiter
 /// @param out_fields Array of resulting fields
 /// @param nfields Size of the field array
-/// @param opt Options that determine the parsing behaviour
-/// @return Number of fields found in the string or -1 if an error occured
+/// @param opt Options that determine the parsing behavior
+/// @return Number of fields found in the string or -1 if an error occurred
 int sv_split(char* str, int len, int startoff, char delim, char** out_fields, int nfields, enum e_svopt opt) {
 	int pos[1024];
 	int i;
@@ -952,7 +966,7 @@ bool sv_readdb(const char* directory, const char* filename, char delim, int minc
 		if( line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
 			continue;
 
-		columns = sv_split(line, strlen(line), 0, delim, fields, fields_length, (e_svopt)(SV_TERMINATE_LF|SV_TERMINATE_CRLF));
+		columns = sv_split(line, (int)strlen(line), 0, delim, fields, fields_length, (e_svopt)(SV_TERMINATE_LF|SV_TERMINATE_CRLF));
 
 		if( columns < mincols ) {
 			ShowError("sv_readdb: Insufficient columns in line %d of \"%s\" (found %d, need at least %d).\n", lines, path, columns, mincols);
@@ -1005,7 +1019,8 @@ void StringBuf_Init(StringBuf* self) {
 }
 
 /// Appends the result of printf to the StringBuf
-int StringBuf_Printf(StringBuf* self, const char* fmt, ...) {
+int StringBuf_Printf(StringBuf *self, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+int StringBuf_Printf(StringBuf *self, const char *fmt, ...) {
 	int len;
 	va_list ap;
 
@@ -1018,7 +1033,8 @@ int StringBuf_Printf(StringBuf* self, const char* fmt, ...) {
 
 /// Appends the result of vprintf to the StringBuf
 int StringBuf_Vprintf(StringBuf* self, const char* fmt, va_list ap) {
-	int n, size, off;
+	int n, off;
+	size_t size;
 
 	for(;;) {
 		va_list apcopy;
@@ -1028,7 +1044,7 @@ int StringBuf_Vprintf(StringBuf* self, const char* fmt, va_list ap) {
 		n = vsnprintf(self->ptr_, size, fmt, apcopy);
 		va_end(apcopy);
 		/* If that worked, return the length. */
-		if( n > -1 && n < size ) {
+		if( n > -1 && (size_t)n < size ) {
 			self->ptr_ += n;
 			return (int)(self->ptr_ - self->buf_);
 		}
@@ -1042,11 +1058,11 @@ int StringBuf_Vprintf(StringBuf* self, const char* fmt, va_list ap) {
 
 /// Appends the contents of another StringBuf to the StringBuf
 int StringBuf_Append(StringBuf* self, const StringBuf* sbuf) {
-	int available = self->max_ - (self->ptr_ - self->buf_);
-	int needed = (int)(sbuf->ptr_ - sbuf->buf_);
+	size_t available = self->max_ - (self->ptr_ - self->buf_);
+	size_t needed = sbuf->ptr_ - sbuf->buf_;
 
 	if( needed >= available ) {
-		int off = (int)(self->ptr_ - self->buf_);
+		size_t off = (self->ptr_ - self->buf_);
 		self->max_ += needed;
 		self->buf_ = (char*)aRealloc(self->buf_, self->max_ + 1);
 		self->ptr_ = self->buf_ + off;
@@ -1059,12 +1075,12 @@ int StringBuf_Append(StringBuf* self, const StringBuf* sbuf) {
 
 // Appends str to the StringBuf
 int StringBuf_AppendStr(StringBuf* self, const char* str)  {
-	int available = self->max_ - (self->ptr_ - self->buf_);
-	int needed = (int)strlen(str);
+	size_t available = self->max_ - (self->ptr_ - self->buf_);
+	size_t needed = strlen(str);
 
 	if( needed >= available ) {
 		// not enough space, expand the buffer (minimum expansion = 1024)
-		int off = (int)(self->ptr_ - self->buf_);
+		size_t off = (self->ptr_ - self->buf_);
 		self->max_ += max(needed, 1024);
 		self->buf_ = (char*)aRealloc(self->buf_, self->max_ + 1);
 		self->ptr_ = self->buf_ + off;
@@ -1118,10 +1134,14 @@ void strlib_defaults(void) {
 	
 #if !(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN)
 	strlib->strnlen = strnlen;
+#else
+	strlib->strnlen = NULL;
 #endif
 	
 #if defined(WIN32) && defined(_MSC_VER) && _MSC_VER <= 1200
 	strlib->strtoull = strtoull;
+#else
+	strlib->strtoull = NULL;
 #endif
 	strlib->e_mail_check = e_mail_check;
 	strlib->config_switch = config_switch;