#pragma once
// udl.hpp - user-defined literals for integers.
//
// Copyright © 2014 Ben Longbons <b.r.longbons@gmail.com>
//
// This file is part of The Mana World (Athena server)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "fwd.hpp"
#include <cstdint>
#include <type_traits>
namespace tmwa
{
namespace ints
{
namespace
{
typedef unsigned long long ullong;
template<char C>
struct CharParser
{
constexpr static
bool is_dec = '0' <= C && C <= '9';
constexpr static
bool is_upper = 'A' <= C && C <= 'F';
constexpr static
bool is_lower = 'a' <= C && C <= 'f';
static_assert(is_dec || is_upper || is_lower, "char base");
constexpr static
ullong value = is_upper ? (C - 'A' + 10) : is_lower ? (C - 'a' + 10) : C - '0';
};
template<ullong base, ullong accum, char... C>
struct BaseParser;
template<ullong base, ullong accum, char F, char... R>
struct BaseParser<base, accum, F, R...>
{
constexpr static
ullong mulled = accum * base;
constexpr static
ullong add = CharParser<F>::value;
static_assert(add < base, "parse base");
constexpr static
ullong added = mulled + add;
static_assert(added > accum || accum == 0, "parse overflow");
constexpr static
ullong value = BaseParser<base, added, R...>::value;
};
template<ullong base, ullong accum>
struct BaseParser<base, accum>
{
constexpr static
ullong value = accum;
};
template<char... C>
struct IntParser
{
constexpr static
ullong value = BaseParser<10, 0, C...>::value;
};
template<char... C>
struct IntParser<'0', C...>
{
constexpr static
ullong value = BaseParser<8, 0, C...>::value;
};
template<char... C>
struct IntParser<'0', 'x', C...>
{
constexpr static
ullong value = BaseParser<16, 0, C...>::value;
};
template<char... C>
struct IntParser<'0', 'X', C...>
{
constexpr static
ullong value = BaseParser<16, 0, C...>::value;
};
template<char... C>
struct IntParser<'0', 'b', C...>
{
constexpr static
ullong value = BaseParser<2, 0, C...>::value;
};
template<char... C>
struct IntParser<'0', 'B', C...>
{
constexpr static
ullong value = BaseParser<2, 0, C...>::value;
};
template<bool S, ullong V>
struct SignedMagnitudeConstant
{
static constexpr
bool sign = S;
static constexpr
ullong magnitude = V;
template<class T>
constexpr
operator T() const
{
typedef typename std::make_unsigned<T>::type U;
// boo, body of constexpr function can't use variables
#define is_signed bool(T(-1) < T(0))
static_assert(is_signed >= (sign && magnitude), "signed");
#define max ullong(ullong(U(-1) >> is_signed))
static_assert(magnitude <= max || (sign && magnitude == max + 1), "magna");
#undef is_signed
#undef max
return sign ? T(ullong(-magnitude)) : T(magnitude);
}
};
template<bool S1, ullong V1, bool S2, ullong V2>
constexpr
bool operator == (SignedMagnitudeConstant<S1, V1>, SignedMagnitudeConstant<S2, V2>)
{
return V1 == V2 && (S1 == S2 || !V1);
}
template<bool S1, ullong V1, bool S2, ullong V2>
constexpr
bool operator != (SignedMagnitudeConstant<S1, V1> lhs, SignedMagnitudeConstant<S2, V2> rhs)
{
return !(lhs == rhs);
}
template<bool S, ullong V>
constexpr
SignedMagnitudeConstant<!S, V> operator -(SignedMagnitudeConstant<S, V>)
{
return {};
}
struct pint8 { int8_t value; int8_t operator +() { return value; } };
struct pint16 { int16_t value; int16_t operator +() { return value; } };
struct pint32 { int32_t value; int32_t operator +() { return value; } };
struct pint64 { int64_t value; int64_t operator +() { return value; } };
struct nint8 { int8_t value; int8_t operator -() { return value; } };
struct nint16 { int16_t value; int16_t operator -() { return value; } };
struct nint32 { int32_t value; int32_t operator -() { return value; } };
struct nint64 { int64_t value; int64_t operator -() { return value; } };
template<char... C>
constexpr
SignedMagnitudeConstant<false, IntParser<C...>::value> operator "" _const()
{ return {}; }
template<char... C>
constexpr
uint8_t operator "" _u8 () { return operator "" _const<C...>(); }
template<char... C>
constexpr
uint16_t operator "" _u16 () { return operator "" _const<C...>(); }
template<char... C>
constexpr
uint32_t operator "" _u32 () { return operator "" _const<C...>(); }
template<char... C>
constexpr
uint64_t operator "" _u64 () { return operator "" _const<C...>(); }
template<char... C>
constexpr
pint8 operator "" _p8 () { return pint8{operator "" _const<C...>()}; }
template<char... C>
constexpr
pint16 operator "" _p16 () { return pint16{operator "" _const<C...>()}; }
template<char... C>
constexpr
pint32 operator "" _p32 () { return pint32{operator "" _const<C...>()}; }
template<char... C>
constexpr
pint64 operator "" _p64 () { return pint64{operator "" _const<C...>()}; }
template<char... C>
constexpr
nint8 operator "" _n8 () { return nint8{-operator "" _const<C...>()}; }
template<char... C>
constexpr
nint16 operator "" _n16 () { return nint16{-operator "" _const<C...>()}; }
template<char... C>
constexpr
nint32 operator "" _n32 () { return nint32{-operator "" _const<C...>()}; }
template<char... C>
constexpr
nint64 operator "" _n64 () { return nint64{-operator "" _const<C...>()}; }
} // anonymous namespace
} // namespace ints
using ints::operator "" _const;
using ints::operator "" _u8;
using ints::operator "" _u16;
using ints::operator "" _u32;
using ints::operator "" _u64;
using ints::operator "" _p8;
using ints::operator "" _p16;
using ints::operator "" _p32;
using ints::operator "" _p64;
using ints::operator "" _n8;
using ints::operator "" _n16;
using ints::operator "" _n32;
using ints::operator "" _n64;
} // namespace tmwa
