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

diff --git a/SPIRV/hex_float.h b/SPIRV/hex_float.h
index 3849eef..4a26ad8 100644 (file)
--- a/SPIRV/hex_float.h
+++ b/SPIRV/hex_float.h
@@ -69,12 +69,12 @@ class Float16 {
 // a value is Nan.
 template <typename T>
 struct FloatProxyTraits {
-  using uint_type = void;
+  typedef void uint_type;
 };
 
 template <>
 struct FloatProxyTraits<float> {
-  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<float> {
 
 template <>
 struct FloatProxyTraits<double> {
-  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<double> {
 
 template <>
 struct FloatProxyTraits<Float16> {
-  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<Float16> {
 template <typename T>
 class FloatProxy {
  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,
   // do not initialize the data by default.
@@ -177,13 +177,13 @@ std::istream& operator>>(std::istream& is, FloatProxy<T>& value) {
 template <typename T>
 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<FloatProxy<float>> {
-  using uint_type = uint32_t;
-  using int_type = int32_t;
-  using underlying_type = FloatProxy<float>;
-  using native_type = float;
+  typedef uint32_t uint_type;
+  typedef int32_t int_type;
+  typedef FloatProxy<float> 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<FloatProxy<float>> {
 // 1 sign bit, 11 exponent bits, 52 fractional bits.
 template <>
 struct HexFloatTraits<FloatProxy<double>> {
-  using uint_type = uint64_t;
-  using int_type = int64_t;
-  using underlying_type = FloatProxy<double>;
-  using native_type = double;
+  typedef uint64_t uint_type;
+  typedef int64_t int_type;
+  typedef FloatProxy<double> 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<FloatProxy<double>> {
 // 1 sign bit, 5 exponent bits, 10 fractional bits.
 template <>
 struct HexFloatTraits<FloatProxy<Float16>> {
-  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 <typename T, typename Traits = HexFloatTraits<T>>
 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>
   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<int_type>(num_fraction_bits) -
         static_cast<int_type>(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 <typename T, typename Traits>
 std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) {
-  using HF = HexFloat<T, Traits>;
-  using uint_type = typename HF::uint_type;
-  using int_type = typename HF::int_type;
+  typedef HexFloat<T, Traits> 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");