spine-runtimes/spine-c/spine-c-unit-tests/memory/KString.cpp

#include "KString.h"
#include <stdarg.h>

#include "MiniCppUnit.hxx"

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// String Helper 

static std::string vasprintf(const char *fmt, va_list argv) {
	std::string result;
	va_list argv_copy; // vsnprintf modifies argv, need copy
#ifndef va_copy
	argv_copy = argv;
#else
	va_copy(argv_copy, argv);
#endif

	int len = vsnprintf(NULL, 0, fmt, argv_copy);
	if (len > 0 && len < 255) {
		// cover 90% of all calls
		char str[256] = {0};
		int len2 = vsnprintf(str, 255, fmt, argv);
		result = str;
	} else if (len > 0) {
		char *str = static_cast<char *>(alloca(len + 1)); // alloca on stack, space for null-termination
		int len2 = vsnprintf(str, len + 1, fmt, argv);
		result = str;
	}
	return result;
}


static void reportWarning(const std::string &warnStr) {
	if (JetBrains::underTeamcity())
		gTeamCityListener.messages.messageWarning(warnStr);
	else
		fprintf(stderr, "%s", warnStr.c_str());
}

static void reportError(const std::string &errorStr) {
	if (JetBrains::underTeamcity())
		gTeamCityListener.messages.messageError(errorStr);
	else
		fprintf(stderr, "%s", errorStr.c_str());
}

static void reportInfo(const std::string &infoStr) {
	if (JetBrains::underTeamcity())
		gTeamCityListener.messages.messageNormal(infoStr);
	else
		fprintf(stderr, "%s", infoStr.c_str());
}

static void reportDebug(const std::string &debugStr) {
	fprintf(stderr, "%s", debugStr.c_str());
}

static void report(ErrorLevel level, const std::string &Str) {
	switch (level) {
		case WARNLVL:
			reportWarning(Str);
			break;
		case ERRORLVL:
			reportError(Str);
			break;
		case INFOLVL:
			reportInfo(Str);
			break;
		case DEBUGLVL:
			reportDebug(Str);
			break;
	}
}

void KOutputDebug(ErrorLevel lvl, const char *fmt ...) {
	va_list argList;
	va_start(argList, fmt);
	std::string str = vasprintf(fmt, argList);
	va_end(argList);

	report(lvl, str);
}

#define K_MAX(a, b) ((a>b) ? a : b)

std::string GetFileName(const std::string &thePath, bool noExtension) {
	int aLastSlash = K_MAX((int) thePath.rfind('\\'), (int) thePath.rfind('/'));

	if (noExtension) {
		int aLastDot = (int) thePath.rfind('.');
		if (aLastDot > aLastSlash)
			return thePath.substr(aLastSlash + 1, aLastDot - aLastSlash - 1);
	}

	if (aLastSlash == -1)
		return thePath;
	else
		return thePath.substr(aLastSlash + 1);
}

std::string GetFileDir(const std::string &thePath, bool withSlash) {
	int aLastSlash = K_MAX((int) thePath.rfind(('\\')), (int) thePath.rfind(('/')));

	if (aLastSlash == -1)
		return ("");
	else {
		if (withSlash)
			return thePath.substr(0, aLastSlash + 1);
		else
			return thePath.substr(0, aLastSlash);
	}
}

std::string GetFileExt(const std::string &thePath) {
	std::string::size_type idx = thePath.find_last_of('.');

	if (idx != std::string::npos)
		return thePath.substr(idx + 1);

	return ("");
}

/**
 * g_ascii_strcasecmp:
 * @s1: string to compare with @s2.
 * @s2: string to compare with @s1.
 *
 * Compare two strings, ignoring the case of ASCII characters.
 *
 * Unlike the BSD strcasecmp() function, this only recognizes standard
 * ASCII letters and ignores the locale, treating all non-ASCII
 * bytes as if they are not letters.
 *
 * This function should be used only on strings that are known to be
 * in encodings where the bytes corresponding to ASCII letters always
 * represent themselves. This includes UTF-8 and the ISO-8859-*
 * charsets, but not for instance double-byte encodings like the
 * Windows Codepage 932, where the trailing bytes of double-byte
 * characters include all ASCII letters. If you compare two CP932
 * strings using this function, you will get false matches.
 *
 * Return value: an integer less than, equal to, or greater than
 *               zero if @s1 is found, respectively, to be less than,
 *               to match, or to be greater than @s2.
 **/
static int g_ascii_compare_caseless(const char *s1, const char *s2) {
#define TOUPPER(c)  (((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 'A' : (c))
#define TOLOWER(c)  (((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' + 'a' : (c))
#define g_return_val_if_fail(expr, val) { if (!(expr)) return (val); }

	int c1, c2;

	g_return_val_if_fail(s1 != NULL, 0);
	g_return_val_if_fail(s2 != NULL, 0);

	while (*s1 && *s2) {
		c1 = (int) (unsigned char) TOLOWER(*s1);
		c2 = (int) (unsigned char) TOLOWER(*s2);
		if (c1 != c2)
			return (c1 - c2);
		s1++;
		s2++;
	}

	return (((int) (unsigned char) *s1) - ((int) (unsigned char) *s2));

#undef g_return_val_if_fail
#undef TOUPPER
#undef TOLOWER
}


int CompareNoCase(const std::string &str1, const std::string &str2) {
	return g_ascii_compare_caseless(str1.c_str(), str2.c_str());
}