Cppcheck report - Fission: libs/fsCore/fsStr.cpp

#include "fsStr.h"

#include <cctype>
#include <cstdlib>
#include <cstring>
#include <sstream>

#include <fsCore/src/debug/fsAssert.h>

const fsStr fsStr::mLineBreakStr = "<br>";
const fsStr fsStr::mLessThanStr = "<";
const fsStr fsStr::mGreaterThanStr = ">";

const fsStr fsStr::mLessThanCode = "&lt;";
const fsStr fsStr::mGreaterThanCode = "&gt;";
const fsStr fsStr::mAmpersandCode = "&amp;";
const fsStr fsStr::mQuoteCode = "&quot;";
const fsStr fsStr::mAposCode = "&apos;";
const fsStr fsStr::mHardSpaceCode = "&#160;";
const fsStr fsStr::mHyphenCode = "&#45;";


const fsU8* fsStr::ptrGet() const
{
	return reinterpret_cast<const fsU8*>(mImpl.c_str());
}

fsStr::fsStr(const char* data, sizeT len)
{
	copy(data, 0, static_cast<int>(len));
}

fsS32 fsStr::count(fsChar pChar) const
{
	fsS32 count = 0;

	const char* p = utf8Get();
	char c = *p++;
	while (c != 0)
	{
		if (pChar == c)
		{
			++count;
		}
		c = *p++;
	}
	return count;
}

void fsStr::formattingRemove()
{
	hTMLCodesReplace();

	removeXmlTags(); // Do this one last as it is indiscriminate
}

namespace
{
	// Rich-text tags (axmol's ax::ui::RichText::createWithXML syntax) are left in place by
	// removeXmlTags() rather than stripped, so bold/italic/colour markup survives localised
	// string loading. Everything else keeps the original indiscriminate-strip behaviour.
	fsBool xmlTagIsRichTextGet(const std::string& pTagInner)
	{
		const size_t nameStart = (!pTagInner.empty() && pTagInner[0] == '/') ? 1 : 0;
		const size_t nameEnd = pTagInner.find_first_of(" \t", nameStart);
		const std::string name = pTagInner.substr(nameStart, nameEnd == std::string::npos ? std::string::npos : nameEnd - nameStart);
		return name == "b" || name == "i" || name == "font";
	}
}

void fsStr::removeXmlTags()
{
	sizeT xmlStart = mImpl.find(mLessThanStr.mImpl);
	while (xmlStart != npos)
	{
		sizeT xmlEnd = mImpl.find(mGreaterThanStr.mImpl, xmlStart);
		if (xmlEnd != npos)
		{
			if (xmlTagIsRichTextGet(mImpl.substr(xmlStart + 1, xmlEnd - xmlStart - 1)))
			{
				xmlStart = mImpl.find(mLessThanStr.mImpl, xmlEnd + mGreaterThanStr.dataSizeGet());
			}
			else
			{
				mImpl = mImpl.erase(xmlStart, xmlEnd + mGreaterThanStr.dataSizeGet() - xmlStart);
				xmlStart = mImpl.find(mLessThanStr.mImpl);
			}
		}
		else
		{
			fsLogError("XML tag ERROR in the string: %s", mImpl.c_str());
			break;
		}

	}
}

void fsStr::hTMLCodesReplace()
{
	replaceAll("%%", "%");

	replaceAll(mLessThanCode, "<");
	replaceAll(mGreaterThanCode, ">");

	replaceAll(mLineBreakStr, "\n");

	if (0 == find(mAmpersandCode))
	{
		erase(0, mAmpersandCode.dataSizeGet());
	}

	replaceAll(mHardSpaceCode, " ");
	replaceAll(mHyphenCode, "-");

	replaceAll(mAmpersandCode, "&");
	replaceAll(mQuoteCode, "\"");
	replaceAll(mAposCode, "\'");
}

fsBool fsStr::isDigit(fsChar pC)
{
	return (pC >= '0' && pC <= '9');
}

fsStr operator+(const fsChar* pLHS, const fsStr& pRHS)
{
	return fsStr(fsStr(pLHS) + pRHS);
}

fsStr operator+(const fsStr& pLHS, const fsChar* pRHS)
{
	return fsStr(pLHS + fsStr(pRHS));
}

fsBool operator==(const fsChar* pLHS, const fsStr& pRhs)
{
	return pRhs == pLHS;
}

fsBool operator!=(const fsChar* pLHS, const fsStr& pRhs)
{
	return pRhs != pLHS;
}

fsStr& fsStr::operator+=(fsS32 pUnicode)
{
	if ((pUnicode & 0xffffff80) == 0)
	{
		mImpl.operator+=(pUnicode);
		return *this;
	}
	fsU8 byte = 0;
	fsS32 numBytes = 4;
	if (pUnicode < 0x800)
	{
		numBytes = 2;
	}
	else if (pUnicode < 0x10000)
	{
		numBytes = 3;
	}
	else
	{
		fsAssert(pUnicode < 0x200000, "Invalid Unicode value");
	}

	switch (numBytes)
	{
	case 2:
		byte = 0xc0; // 110xxxxx
		byte |= ((pUnicode & 0x07c0) >> 6); // ---- -xxx xx-- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= (pUnicode & 0x003f); // ---- ---- --xx xxxx
		mImpl.push_back(byte);

		break;

	case 3:
		byte = 0xe0; // 1110xxxx
		byte |= ((pUnicode & 0xf000) >> 12); // xxxx ---- ---- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= ((pUnicode & 0x0fc0) >> 6); // ---- xxxx xx-- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= (pUnicode & 0x003f); // ---- ---- --xx xxxx
		mImpl.push_back(byte);

		break;

	case 4:
		byte = 0xf0; // 11110xxx
		byte |= ((pUnicode & 0x1c0000) >> 18); // ---x xx-- ---- ---- ---- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= ((pUnicode & 0x03f000) >> 12); // ---- --xx xxxx ---- ---- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= ((pUnicode & 0x000fc0) >> 6); // ---- ---- ---- xxxx xx-- ----
		mImpl.push_back(byte);

		byte = 0x80; // 10xxxxxx
		byte |= (pUnicode & 0x0000003f); // ---- ---- ---- ---- --xx xxxx
		mImpl.push_back(byte);

		break;

	default:
		fsAssert(false, "Something went wrong.");
		break;
	}
	return *this;
}

fsStr::sizeT fsStr::lengthGet() const
{
	sizeT ret = 0;
	fsU32 currBytePos = 0;

	while (mImpl[currBytePos] != 0)
	{
		const fsU8 currByte = mImpl[currBytePos++];
		if ((currByte & 0x80) == 0) // Normal ASCII range
		{
			++ret;
		}
		else
		{
			fsU32 shift = 6;
			while ((currByte & (1 << shift--)) != 0)
			{
				++currBytePos;
			}

			++ret;
		}
	}

	return ret;
}

void fsStr::eraseToLast(const fsStr& pMatch)
{
	sizeT matchPos = rfind(pMatch);
	if (npos != matchPos)
	{
		erase(0, matchPos + pMatch.dataSizeGet());
	}
}

void fsStr::eraseFromLast(const fsStr& pMatch)
{
	sizeT matchPos = rfind(pMatch);
	if (npos != matchPos)
	{
		erase(matchPos);
	}
}

fsStr fsStr::chomp(const fsStr& pTerm)
{
	const sizeT termLoc = this->find(pTerm);
	if (npos == termLoc)
	{
		const fsStr bite(*this);
		mImpl = "";
		return bite;
	}
	fsStr bite;
	bite.mImpl = mImpl.substr(0, termLoc);
	this->erase(0, termLoc + pTerm.dataSizeGet());
	if (pTerm == "\n")
	{
		if (!bite.emptyGet() && bite[bite.dataSizeGet() - 1] == '\r')
		{
			bite.erase(bite.dataSizeGet() - 1);
		}
	}
	return bite;
}

fsStr fsStr::chunk()
{
	leadingWhitespaceTrim();
	while (dataSizeGet() > 0 && '#' == mImpl[0])
	{
		chomp("\n");
		leadingWhitespaceTrim();
	}

	if (dataSizeGet() > 0 && '\"' == mImpl[0])
	{
		erase(0, 1);
		fsAssert(npos != find( "\"" ), "Missing '\"' in string.\n");
		return chomp("\"");
	}

	fsS32 numGoodChars = 0;
	if (dataSizeGet() > 0)
	{
		while ('=' != mImpl[numGoodChars] &&
			mSpaceChar != mImpl[numGoodChars] &&
			mTabChar != mImpl[numGoodChars] &&
			mNewLineChar != mImpl[numGoodChars] &&
			mLineFeedChar != mImpl[numGoodChars] &&
			0 != mImpl[numGoodChars])
		{
			++numGoodChars;
		}
	}

	fsStr bite;
	if (numGoodChars > 0)
	{
		bite.copy(utf8Get(), 0, numGoodChars);
		erase(0, numGoodChars);
		leadingWhitespaceTrim();
	}
	return bite;
}

void fsStr::leadingWhitespaceTrim()
{
	fsS32 firstGoodChar = 0;
	while (firstGoodChar < static_cast<fsS32>(dataSizeGet())
		&& (mSpaceChar == mImpl[firstGoodChar] || mTabChar == mImpl[firstGoodChar] ||
			mNewLineChar == mImpl[firstGoodChar] || mLineFeedChar == mImpl[firstGoodChar]))
	{
		++firstGoodChar;
	}
	if (firstGoodChar > 0)
	{
		erase(0, firstGoodChar);
	}
}

void fsStr::trailingWhitespaceTrim()
{
	fsS32 lastGoodChar = dataSizeGet() - 1;
	while (lastGoodChar >= 0 && (mSpaceChar == mImpl[lastGoodChar] || mTabChar == mImpl[lastGoodChar] ||
		mNewLineChar == mImpl[lastGoodChar] || mLineFeedChar == mImpl[lastGoodChar]))
	{
		--lastGoodChar;
	}
	if (lastGoodChar < (static_cast<fsS32>(dataSizeGet()) - 1))
	{
		erase(lastGoodChar + 1);
	}
}

void fsStr::trimToLength(fsS32 pNumChars)
{
	fsS32 charsToErase = lengthGet() - pNumChars;
	fsS32 bytesToErase = 0;
	while (charsToErase-- > 0)
	{
		++bytesToErase;
		while ((mImpl[dataSizeGet() - bytesToErase] & 0xc0) == 0x80)
		{
			++bytesToErase;
		}
	}

	if (bytesToErase > 0)
	{
		erase(dataSizeGet() - bytesToErase, bytesToErase);
	}
}

void fsStr::copy(const char* pString)
{
	copy(pString, 0, static_cast<int>(strlen(pString)));
}

void fsStr::copy(const char* pString, int pStart, int pCount)
{
	if (pString == nullptr || pCount <= 0)
	{
		mImpl.clear();
		return;
	}

	mImpl.assign(pString + pStart, static_cast<std::string::size_type>(pCount));
}

void fsStr::stringSet(const char* str, int len)
{
	copy(str, 0, len);
}

fsBool fsStr::isAlphaNumeric() const
{
	const char* p = utf8Get();
	char c = *p++;
	while (c != 0)
	{
		if (!std::isalnum(static_cast<unsigned char>(c)))
		{
			return false;
		}
		c = *p++;
	}
	return true;
}

void fsStr::downcase()
{
	for (auto& c : mImpl)
	{
		c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));<--- Consider using std::transform algorithm instead of a raw loop.
	}
}

void fsStr::upcase()
{
	for (auto& c : mImpl)
	{
		c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));<--- Consider using std::transform algorithm instead of a raw loop.
	}
}

fsBool fsStr::compare(const char* pString, int len) const
{
	const char* data = utf8Get();
	return memcmp(data, pString, len) == 0;
}

fsF32 fsStr::toF32() const
{
	return static_cast<fsF32>(strtod(mImpl.c_str(), nullptr));
}

fsS32 fsStr::toS32() const
{
	return strtol(mImpl.c_str(), nullptr, 10);
}

fsU32 fsStr::toU32() const
{
	return strtoul(mImpl.c_str(), nullptr, 10);
}

fsS64 fsStr::toS64() const
{
	return strtoll(mImpl.c_str(), nullptr, 10);
}

void fsStr::replaceFirst(const fsStr& pFind, const fsStr& pReplace)
{
	if (pFind.emptyGet())
	{
		return;
	}

	sizeT p = mImpl.find(pFind.mImpl);
	if (p != npos)
	{
		mImpl.replace(p, pFind.dataSizeGet(), pReplace.mImpl);
	}
}

void fsStr::replaceAll(const fsStr& pFind, const fsStr& pReplace)
{
	if (pFind.emptyGet())
	{
		return;
	}

	sizeT p = mImpl.find(pFind.mImpl);
	while (p != npos)
	{
		mImpl.replace(p, pFind.dataSizeGet(), pReplace.mImpl);
		p = mImpl.find(pFind.mImpl, p + pReplace.dataSizeGet());
	}
}