#include "mathlib.h"

#include "errorlogger.h"

#include "utils.h"

#include <cctype>

#include <cmath>

#include <cstdlib>

#include <limits>

#include <locale>

#if defined(_MSC_VER) && _MSC_VER <= 1700 // VS2012 doesn't have std::isinf and std::isnan

#define ISINF(x) (!_finite(x))

#define ISNAN(x) (_isnan(x))

#elif defined(__INTEL_COMPILER)

#define ISINF(x) (isinf(x))

#define ISNAN(x) (isnan(x))

#else // Use C++11 functions

#define ISINF(x) (std::isinf(x))

#define ISNAN(x) (std::isnan(x))

#endif

const int MathLib::bigint_bits = 64;

MathLib::value::value(const std::string &s) :

mIntValue(0), mDoubleValue(0), mIsUnsigned(false)

{

if (MathLib::isFloat(s)) {

mType = MathLib::value::FLOAT;

mDoubleValue = MathLib::toDoubleNumber(s);

return;

}

if (!MathLib::isInt(s))

throw InternalError(nullptr, "Invalid value: " + s);

mType = MathLib::value::INT;

mIntValue = MathLib::toLongNumber(s);

if (isIntHex(s) && mIntValue < 0)

mIsUnsigned = true;

// read suffix

if (s.size() >= 2U) {

for (std::size_t i = s.size() - 1U; i > 0U; --i) {

const char c = s[i];

if (c == 'u' || c == 'U')

mIsUnsigned = true;

else if (c == 'l' || c == 'L') {

if (mType == MathLib::value::INT)

mType = MathLib::value::LONG;

else if (mType == MathLib::value::LONG)

mType = MathLib::value::LONGLONG;

} else if (i > 2U && c == '4' && s[i-1] == '6' && s[i-2] == 'i')

mType = MathLib::value::LONGLONG;

}

}

}

std::string MathLib::value::str() const

{

std::ostringstream ostr;

if (mType == MathLib::value::FLOAT) {

if (ISNAN(mDoubleValue))

return "nan.0";

if (ISINF(mDoubleValue))

return (mDoubleValue > 0) ? "inf.0" : "-inf.0";

ostr.precision(9);

ostr << std::fixed << mDoubleValue;

// remove trailing zeros

std::string ret(ostr.str());

std::string::size_type pos = ret.size() - 1U;

while (ret[pos] == '0')

pos--;

if (ret[pos] == '.')

++pos;

return ret.substr(0, pos+1);

}

if (mIsUnsigned)

ostr << static_cast<biguint>(mIntValue) << "U";

else

ostr << mIntValue;

if (mType == MathLib::value::LONG)

ostr << "L";

else if (mType == MathLib::value::LONGLONG)

ostr << "LL";

return ostr.str();

}

void MathLib::value::promote(const MathLib::value &v)

{

if (isInt() && v.isInt()) {

if (mType < v.mType) {

mType = v.mType;

mIsUnsigned = v.mIsUnsigned;

} else if (mType == v.mType) {

mIsUnsigned |= v.mIsUnsigned;

}

} else if (!isFloat()) {

mIsUnsigned = false;

mDoubleValue = mIntValue;

mType = MathLib::value::FLOAT;

}

}

MathLib::value MathLib::value::calc(char op, const MathLib::value &v1, const MathLib::value &v2)

{

value temp(v1);

temp.promote(v2);

if (temp.isFloat()) {

switch (op) {

case '+':

temp.mDoubleValue += v2.getDoubleValue();

break;

case '-':

temp.mDoubleValue -= v2.getDoubleValue();

break;

case '*':

temp.mDoubleValue *= v2.getDoubleValue();

break;

case '/':

temp.mDoubleValue /= v2.getDoubleValue();

break;

case '%':

case '&':

case '|':

case '^':

throw InternalError(nullptr, "Invalid calculation");

default:

throw InternalError(nullptr, "Unhandled calculation");

}

} else if (temp.mIsUnsigned) {

switch (op) {

case '+':

temp.mIntValue += (unsigned long long)v2.mIntValue;

break;

case '-':

temp.mIntValue -= (unsigned long long)v2.mIntValue;

break;

case '*':

temp.mIntValue *= (unsigned long long)v2.mIntValue;

break;

case '/':

if (v2.mIntValue == 0)

throw InternalError(nullptr, "Internal Error: Division by zero");

if (v1.mIntValue == std::numeric_limits<bigint>::min() && std::abs(v2.mIntValue)<=1)

throw InternalError(nullptr, "Internal Error: Division overflow");

temp.mIntValue /= (unsigned long long)v2.mIntValue;

break;

case '%':

if (v2.mIntValue == 0)

throw InternalError(nullptr, "Internal Error: Division by zero");

temp.mIntValue %= (unsigned long long)v2.mIntValue;

break;

case '&':

temp.mIntValue &= (unsigned long long)v2.mIntValue;

break;

case '|':

temp.mIntValue |= (unsigned long long)v2.mIntValue;

break;

case '^':

temp.mIntValue ^= (unsigned long long)v2.mIntValue;

break;

default:

throw InternalError(nullptr, "Unhandled calculation");

}

} else {

switch (op) {

case '+':

temp.mIntValue += v2.mIntValue;

break;

case '-':

temp.mIntValue -= v2.mIntValue;

break;

case '*':

temp.mIntValue *= v2.mIntValue;

break;

case '/':

if (v2.mIntValue == 0)

throw InternalError(nullptr, "Internal Error: Division by zero");

if (v1.mIntValue == std::numeric_limits<bigint>::min() && std::abs(v2.mIntValue)<=1)

throw InternalError(nullptr, "Internal Error: Division overflow");

temp.mIntValue /= v2.mIntValue;

break;

case '%':

if (v2.mIntValue == 0)

throw InternalError(nullptr, "Internal Error: Division by zero");

temp.mIntValue %= v2.mIntValue;

break;

case '&':

temp.mIntValue &= v2.mIntValue;

break;

case '|':

temp.mIntValue |= v2.mIntValue;

break;

case '^':

temp.mIntValue ^= v2.mIntValue;

break;

default:

throw InternalError(nullptr, "Unhandled calculation");

}

}

return temp;

}

int MathLib::value::compare(const MathLib::value &v) const

{

value temp(*this);

temp.promote(v);

if (temp.isFloat()) {

if (temp.mDoubleValue < v.getDoubleValue())

return -1;

if (temp.mDoubleValue > v.getDoubleValue())

return 1;

return 0;

}

if (temp.mIsUnsigned) {

if ((unsigned long long)mIntValue < (unsigned long long)v.mIntValue)

return -1;

if ((unsigned long long)mIntValue > (unsigned long long)v.mIntValue)

return 1;

return 0;

}

if (mIntValue < v.mIntValue)

return -1;

if (mIntValue > v.mIntValue)

return 1;

return 0;

}

MathLib::value MathLib::value::add(int v) const

{

MathLib::value temp(*this);

if (temp.isInt())

temp.mIntValue += v;

else

temp.mDoubleValue += v;

return temp;

}

MathLib::value MathLib::value::shiftLeft(const MathLib::value &v) const

{

if (!isInt() || !v.isInt())

throw InternalError(nullptr, "Shift operand is not integer");

MathLib::value ret(*this);

if (v.mIntValue >= MathLib::bigint_bits) {

return ret;

}

ret.mIntValue <<= v.mIntValue;

return ret;

}

MathLib::value MathLib::value::shiftRight(const MathLib::value &v) const

{

if (!isInt() || !v.isInt())

throw InternalError(nullptr, "Shift operand is not integer");

MathLib::value ret(*this);

if (v.mIntValue >= MathLib::bigint_bits) {

return ret;

}

ret.mIntValue >>= v.mIntValue;

return ret;

}

MathLib::biguint MathLib::toULongNumber(const std::string & str)

}

static unsigned int encodeMultiChar(const std::string& str)

}

static bool isoctal(int c)

{

return c>='0' && c<='7';

}

MathLib::bigint MathLib::characterLiteralToLongNumber(const std::string& str)

}

std::string MathLib::normalizeCharacterLiteral(const std::string& iLiteral)

}

MathLib::bigint MathLib::toLongNumber(const std::string & str)

}

static double myStod(const std::string& str, std::string::const_iterator from, std::string::const_iterator to, int base)

}

static double floatHexToDoubleNumber(const std::string& str)

}

double MathLib::toDoubleNumber(const std::string &str)

}

template<> std::string MathLib::toString(double value)

}

bool MathLib::isFloat(const std::string &str)

{

return isDecimalFloat(str) || isFloatHex(str);

}

bool MathLib::isDecimalFloat(const std::string &str)

}

bool MathLib::isNegative(const std::string &str)

}

bool MathLib::isPositive(const std::string &str)

}

static bool isValidIntegerSuffixIt(std::string::const_iterator it, std::string::const_iterator end, bool supportMicrosoftExtensions=true)

}

bool MathLib::isValidIntegerSuffix(const std::string& str, bool supportMicrosoftExtensions)

{

return isValidIntegerSuffixIt(str.begin(), str.end(), supportMicrosoftExtensions);

}

bool MathLib::isOct(const std::string& str)

}

bool MathLib::isIntHex(const std::string& str)

}

bool MathLib::isFloatHex(const std::string& str)