mewin/glslang
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Change "using x = y;" to "typedef y x;" statements

Browse Source
This commit is contained in:
baldurk 2016-10-13 19:31:15 +02:00
parent a227d27227
commit 7cac9e7245
1 changed files with 30 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
SPIRV/hex_float.h
View File

@ -69,12 +69,12 @@ class Float16 {
// a value is Nan. // a value is Nan.
template <typename T> template <typename T>
struct FloatProxyTraits { struct FloatProxyTraits {
using uint_type = void; typedef void uint_type;
}; };
template <> template <>
struct FloatProxyTraits<float> { struct FloatProxyTraits<float> {
using uint_type = uint32_t; typedef uint32_t uint_type;
static bool isNan(float f) { return std::isnan(f); } static bool isNan(float f) { return std::isnan(f); }
// Returns true if the given value is any kind of infinity. // Returns true if the given value is any kind of infinity.
static bool isInfinity(float f) { return std::isinf(f); } static bool isInfinity(float f) { return std::isinf(f); }
@ -86,7 +86,7 @@ struct FloatProxyTraits<float> {
template <> template <>
struct FloatProxyTraits<double> { struct FloatProxyTraits<double> {
using uint_type = uint64_t; typedef uint64_t uint_type;
static bool isNan(double f) { return std::isnan(f); } static bool isNan(double f) { return std::isnan(f); }
// Returns true if the given value is any kind of infinity. // Returns true if the given value is any kind of infinity.
static bool isInfinity(double f) { return std::isinf(f); } static bool isInfinity(double f) { return std::isinf(f); }
@ -98,7 +98,7 @@ struct FloatProxyTraits<double> {
template <> template <>
struct FloatProxyTraits<Float16> { struct FloatProxyTraits<Float16> {
using uint_type = uint16_t; typedef uint16_t uint_type;
static bool isNan(Float16 f) { return Float16::isNan(f); } static bool isNan(Float16 f) { return Float16::isNan(f); }
// Returns true if the given value is any kind of infinity. // Returns true if the given value is any kind of infinity.
static bool isInfinity(Float16 f) { return Float16::isInfinity(f); } static bool isInfinity(Float16 f) { return Float16::isInfinity(f); }
@ -114,7 +114,7 @@ struct FloatProxyTraits<Float16> {
template <typename T> template <typename T>
class FloatProxy { class FloatProxy {
public: public:
using uint_type = typename FloatProxyTraits<T>::uint_type; typedef typename FloatProxyTraits<T>::uint_type uint_type;
// Since this is to act similar to the normal floats, // Since this is to act similar to the normal floats,
// do not initialize the data by default. // do not initialize the data by default.
@ -177,13 +177,13 @@ std::istream& operator>>(std::istream& is, FloatProxy<T>& value) {
template <typename T> template <typename T>
struct HexFloatTraits { struct HexFloatTraits {
// Integer type that can store this hex-float. // Integer type that can store this hex-float.
using uint_type = void; typedef void uint_type;
// Signed integer type that can store this hex-float. // Signed integer type that can store this hex-float.
using int_type = void; typedef void int_type;
// The numerical type that this HexFloat represents. // The numerical type that this HexFloat represents.
using underlying_type = void; typedef void underlying_type;
// The type needed to construct the underlying type. // The type needed to construct the underlying type.
using native_type = void; typedef void native_type;
// The number of bits that are actually relevant in the uint_type. // The number of bits that are actually relevant in the uint_type.
// This allows us to deal with, for example, 24-bit values in a 32-bit // This allows us to deal with, for example, 24-bit values in a 32-bit
// integer. // integer.
@ -201,10 +201,10 @@ struct HexFloatTraits {
// 1 sign bit, 8 exponent bits, 23 fractional bits. // 1 sign bit, 8 exponent bits, 23 fractional bits.
template <> template <>
struct HexFloatTraits<FloatProxy<float>> { struct HexFloatTraits<FloatProxy<float>> {
using uint_type = uint32_t; typedef uint32_t uint_type;
using int_type = int32_t; typedef int32_t int_type;
using underlying_type = FloatProxy<float>; typedef FloatProxy<float> underlying_type;
using native_type = float; typedef float native_type;
static const uint_type num_used_bits = 32; static const uint_type num_used_bits = 32;
static const uint_type num_exponent_bits = 8; static const uint_type num_exponent_bits = 8;
static const uint_type num_fraction_bits = 23; static const uint_type num_fraction_bits = 23;
@ -215,10 +215,10 @@ struct HexFloatTraits<FloatProxy<float>> {
// 1 sign bit, 11 exponent bits, 52 fractional bits. // 1 sign bit, 11 exponent bits, 52 fractional bits.
template <> template <>
struct HexFloatTraits<FloatProxy<double>> { struct HexFloatTraits<FloatProxy<double>> {
using uint_type = uint64_t; typedef uint64_t uint_type;
using int_type = int64_t; typedef int64_t int_type;
using underlying_type = FloatProxy<double>; typedef FloatProxy<double> underlying_type;
using native_type = double; typedef double native_type;
static const uint_type num_used_bits = 64; static const uint_type num_used_bits = 64;
static const uint_type num_exponent_bits = 11; static const uint_type num_exponent_bits = 11;
static const uint_type num_fraction_bits = 52; static const uint_type num_fraction_bits = 52;
@ -229,10 +229,10 @@ struct HexFloatTraits<FloatProxy<double>> {
// 1 sign bit, 5 exponent bits, 10 fractional bits. // 1 sign bit, 5 exponent bits, 10 fractional bits.
template <> template <>
struct HexFloatTraits<FloatProxy<Float16>> { struct HexFloatTraits<FloatProxy<Float16>> {
using uint_type = uint16_t; typedef uint16_t uint_type;
using int_type = int16_t; typedef int16_t int_type;
using underlying_type = uint16_t; typedef uint16_t underlying_type;
using native_type = uint16_t; typedef uint16_t native_type;
static const uint_type num_used_bits = 16; static const uint_type num_used_bits = 16;
static const uint_type num_exponent_bits = 5; static const uint_type num_exponent_bits = 5;
static const uint_type num_fraction_bits = 10; static const uint_type num_fraction_bits = 10;
@ -252,10 +252,10 @@ enum round_direction {
template <typename T, typename Traits = HexFloatTraits<T>> template <typename T, typename Traits = HexFloatTraits<T>>
class HexFloat { class HexFloat {
public: public:
using uint_type = typename Traits::uint_type; typedef typename Traits::uint_type uint_type;
using int_type = typename Traits::int_type; typedef typename Traits::int_type int_type;
using underlying_type = typename Traits::underlying_type; typedef typename Traits::underlying_type underlying_type;
using native_type = typename Traits::native_type; typedef typename Traits::native_type native_type;
explicit HexFloat(T f) : value_(f) {} explicit HexFloat(T f) : value_(f) {}
@ -491,7 +491,7 @@ class HexFloat {
template <typename other_T> template <typename other_T>
typename other_T::uint_type getRoundedNormalizedSignificand( typename other_T::uint_type getRoundedNormalizedSignificand(
round_direction dir, bool* carry_bit) { round_direction dir, bool* carry_bit) {
using other_uint_type = typename other_T::uint_type; typedef typename other_T::uint_type other_uint_type;
static const int_type num_throwaway_bits = static const int_type num_throwaway_bits =
static_cast<int_type>(num_fraction_bits) - static_cast<int_type>(num_fraction_bits) -
static_cast<int_type>(other_T::num_fraction_bits); static_cast<int_type>(other_T::num_fraction_bits);
@ -637,7 +637,7 @@ class HexFloat {
bool round_underflow_up = bool round_underflow_up =
isNegative() ? round_dir == kRoundToNegativeInfinity isNegative() ? round_dir == kRoundToNegativeInfinity
: round_dir == kRoundToPositiveInfinity; : round_dir == kRoundToPositiveInfinity;
using other_int_type = typename other_T::int_type; typedef typename other_T::int_type other_int_type;
// setFromSignUnbiasedExponentAndNormalizedSignificand will // setFromSignUnbiasedExponentAndNormalizedSignificand will
// zero out any underflowing value (but retain the sign). // zero out any underflowing value (but retain the sign).
other.setFromSignUnbiasedExponentAndNormalizedSignificand( other.setFromSignUnbiasedExponentAndNormalizedSignificand(
@ -676,9 +676,9 @@ inline uint8_t get_nibble_from_character(int character) {
// Outputs the given HexFloat to the stream. // Outputs the given HexFloat to the stream.
template <typename T, typename Traits> template <typename T, typename Traits>
std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) { std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) {
using HF = HexFloat<T, Traits>; typedef HexFloat<T, Traits> HF;
using uint_type = typename HF::uint_type; typedef typename HF::uint_type uint_type;
using int_type = typename HF::int_type; typedef typename HF::int_type int_type;
static_assert(HF::num_used_bits != 0, static_assert(HF::num_used_bits != 0,
"num_used_bits must be non-zero for a valid float"); "num_used_bits must be non-zero for a valid float");