From 7cac9e7245c6ce5cdc36f7a9473b994d239a2094 Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 13 Oct 2016 19:31:15 +0200 Subject: [PATCH] Change "using x = y;" to "typedef y x;" statements --- SPIRV/hex_float.h | 60 +++++++++++++++++++++++------------------------ 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/SPIRV/hex_float.h b/SPIRV/hex_float.h index 3849eeff..4a26ad8c 100644 --- a/SPIRV/hex_float.h +++ b/SPIRV/hex_float.h @@ -69,12 +69,12 @@ class Float16 { // a value is Nan. template struct FloatProxyTraits { - using uint_type = void; + typedef void uint_type; }; template <> struct FloatProxyTraits { - using uint_type = uint32_t; + typedef uint32_t uint_type; static bool isNan(float f) { return std::isnan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(float f) { return std::isinf(f); } @@ -86,7 +86,7 @@ struct FloatProxyTraits { template <> struct FloatProxyTraits { - using uint_type = uint64_t; + typedef uint64_t uint_type; static bool isNan(double f) { return std::isnan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(double f) { return std::isinf(f); } @@ -98,7 +98,7 @@ struct FloatProxyTraits { template <> struct FloatProxyTraits { - using uint_type = uint16_t; + typedef uint16_t uint_type; static bool isNan(Float16 f) { return Float16::isNan(f); } // Returns true if the given value is any kind of infinity. static bool isInfinity(Float16 f) { return Float16::isInfinity(f); } @@ -114,7 +114,7 @@ struct FloatProxyTraits { template class FloatProxy { public: - using uint_type = typename FloatProxyTraits::uint_type; + typedef typename FloatProxyTraits::uint_type uint_type; // Since this is to act similar to the normal floats, // do not initialize the data by default. @@ -177,13 +177,13 @@ std::istream& operator>>(std::istream& is, FloatProxy& value) { template struct HexFloatTraits { // 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. - using int_type = void; + typedef void int_type; // The numerical type that this HexFloat represents. - using underlying_type = void; + typedef void 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. // This allows us to deal with, for example, 24-bit values in a 32-bit // integer. @@ -201,10 +201,10 @@ struct HexFloatTraits { // 1 sign bit, 8 exponent bits, 23 fractional bits. template <> struct HexFloatTraits> { - using uint_type = uint32_t; - using int_type = int32_t; - using underlying_type = FloatProxy; - using native_type = float; + typedef uint32_t uint_type; + typedef int32_t int_type; + typedef FloatProxy underlying_type; + typedef float native_type; static const uint_type num_used_bits = 32; static const uint_type num_exponent_bits = 8; static const uint_type num_fraction_bits = 23; @@ -215,10 +215,10 @@ struct HexFloatTraits> { // 1 sign bit, 11 exponent bits, 52 fractional bits. template <> struct HexFloatTraits> { - using uint_type = uint64_t; - using int_type = int64_t; - using underlying_type = FloatProxy; - using native_type = double; + typedef uint64_t uint_type; + typedef int64_t int_type; + typedef FloatProxy underlying_type; + typedef double native_type; static const uint_type num_used_bits = 64; static const uint_type num_exponent_bits = 11; static const uint_type num_fraction_bits = 52; @@ -229,10 +229,10 @@ struct HexFloatTraits> { // 1 sign bit, 5 exponent bits, 10 fractional bits. template <> struct HexFloatTraits> { - using uint_type = uint16_t; - using int_type = int16_t; - using underlying_type = uint16_t; - using native_type = uint16_t; + typedef uint16_t uint_type; + typedef int16_t int_type; + typedef uint16_t underlying_type; + typedef uint16_t native_type; static const uint_type num_used_bits = 16; static const uint_type num_exponent_bits = 5; static const uint_type num_fraction_bits = 10; @@ -252,10 +252,10 @@ enum round_direction { template > class HexFloat { public: - using uint_type = typename Traits::uint_type; - using int_type = typename Traits::int_type; - using underlying_type = typename Traits::underlying_type; - using native_type = typename Traits::native_type; + typedef typename Traits::uint_type uint_type; + typedef typename Traits::int_type int_type; + typedef typename Traits::underlying_type underlying_type; + typedef typename Traits::native_type native_type; explicit HexFloat(T f) : value_(f) {} @@ -491,7 +491,7 @@ class HexFloat { template typename other_T::uint_type getRoundedNormalizedSignificand( 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_cast(num_fraction_bits) - static_cast(other_T::num_fraction_bits); @@ -637,7 +637,7 @@ class HexFloat { bool round_underflow_up = isNegative() ? round_dir == kRoundToNegativeInfinity : round_dir == kRoundToPositiveInfinity; - using other_int_type = typename other_T::int_type; + typedef typename other_T::int_type other_int_type; // setFromSignUnbiasedExponentAndNormalizedSignificand will // zero out any underflowing value (but retain the sign). other.setFromSignUnbiasedExponentAndNormalizedSignificand( @@ -676,9 +676,9 @@ inline uint8_t get_nibble_from_character(int character) { // Outputs the given HexFloat to the stream. template std::ostream& operator<<(std::ostream& os, const HexFloat& value) { - using HF = HexFloat; - using uint_type = typename HF::uint_type; - using int_type = typename HF::int_type; + typedef HexFloat HF; + typedef typename HF::uint_type uint_type; + typedef typename HF::int_type int_type; static_assert(HF::num_used_bits != 0, "num_used_bits must be non-zero for a valid float");