mirror of
https://github.com/libretro/bsnes-libretro.git
synced 2024-11-23 08:59:40 +00:00
17fc6d8d51
byuu says: This WIP is just work on nall/primitives ... Basically, I'm coming to the conclusion that it's just not practical to try and make Natural/Integer implicitly castable to primitive signed and unsigned integers. C++ just has too many edge cases there. I also want to get away from the problem of C++ deciding that all math operations return 32-bit values, unless one of the parameters is 64-bit, in which case you get a 64-bit value. You know, so things like array[-1] won't end up accessing the 4 billionth element of the array. It's nice to be fancy and minimally size operations (eg 32-bit+32-bit = 33-bit), but it's just too unintuitive. I think all Natural<X>+Natural<Y> expessions should result in a Natural<64> (eg natural) type. nall/primitives/operators.hpp has been removed, and new Natural<>Natural / Integer<>Integer casts exist. My feeling is that signed and unsigned types should not be implicitly convertible where data loss can occur. In the future, I think an integer8*natural8 is fine to return an integer64, and the bitwise operators are probably all fine between the two types. I could probably add (Integer,Natural)+Boolean conversions as well. To simplify expressions, there are new user-defined literals for _b (boolean), _n (natural), _i (integer), _r (real), _n# (eg _n8), _i# (eg _i8), _r# (eg _r32), and _s (nall::string). In the long-term, my intention is to make the conversion and cast constructors explicit for primitive types, but obviously that'll shatter most of higan, so for now that won't be the case. Something I can do in the future is allow implicit conversion and casting to (u)int64_t. That may be a nice balance.
24 lines
700 B
C++
24 lines
700 B
C++
#pragma once
|
|
|
|
#include <nall/serializer.hpp>
|
|
#include <nall/traits.hpp>
|
|
|
|
namespace nall {
|
|
struct Boolean;
|
|
template<int Precision> struct Natural;
|
|
template<int Precision> struct Integer;
|
|
}
|
|
|
|
#include <nall/primitives/bit-range.hpp>
|
|
#include <nall/primitives/boolean.hpp>
|
|
#include <nall/primitives/natural.hpp>
|
|
#include <nall/primitives/integer.hpp>
|
|
#include <nall/primitives/real.hpp>
|
|
#include <nall/primitives/types.hpp>
|
|
#include <nall/primitives/literals.hpp>
|
|
|
|
namespace nall {
|
|
template<int Bits> auto Natural<Bits>::integer() const -> Integer<Bits> { return Integer<Bits>(*this); }
|
|
template<int Bits> auto Integer<Bits>::natural() const -> Natural<Bits> { return Natural<Bits>(*this); }
|
|
}
|