general: Do away with TYPENAME macro

direct/src/dcparser/dcNumericRange.I

@@ -58,7 +58,7 @@ is_in_range(Number num) const {
     return true;
   }
 
-  TYPENAME Ranges::const_iterator ri;
+  typename Ranges::const_iterator ri;
   for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
     if (num >= (*ri)._min && num <= (*ri)._max) {
       return true;
@@ -96,7 +96,7 @@ has_one_value() const {
  * by the numeric range.
  */
 template <class NUM>
-INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
+INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
 get_one_value() const {
   nassertr(has_one_value(), 0);
   return _ranges[0]._min;
@@ -110,7 +110,7 @@ void DCNumericRange<NUM>::
 generate_hash(HashGenerator &hashgen) const {
   if (!_ranges.empty()) {
     hashgen.add_int(_ranges.size());
-    TYPENAME Ranges::const_iterator ri;
+    typename Ranges::const_iterator ri;
     for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
       // We don't account for the fractional part of floating-point ranges
       // here.  Shouldn't be a real issue.
@@ -127,7 +127,7 @@ template <class NUM>
 void DCNumericRange<NUM>::
 output(ostream &out, Number divisor) const {
   if (!_ranges.empty()) {
-    TYPENAME Ranges::const_iterator ri;
+    typename Ranges::const_iterator ri;
     ri = _ranges.begin();
     output_minmax(out, divisor, *ri);
     ++ri;
@@ -151,7 +151,7 @@ output_char(ostream &out, Number divisor) const {
 
   } else {
     if (!_ranges.empty()) {
-      TYPENAME Ranges::const_iterator ri;
+      typename Ranges::const_iterator ri;
       ri = _ranges.begin();
       output_minmax_char(out, *ri);
       ++ri;
@@ -187,7 +187,7 @@ add_range(Number min, Number max) {
     return false;
   }
 
-  TYPENAME Ranges::const_iterator ri;
+  typename Ranges::const_iterator ri;
   for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
     if ((min >= (*ri)._min && min <= (*ri)._max) ||
         (max >= (*ri)._min && max <= (*ri)._max) ||
@@ -227,7 +227,7 @@ get_num_ranges() const {
  * Returns the minimum value defined by the nth component.
  */
 template <class NUM>
-INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
+INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
 get_min(int n) const {
   nassertr(n >= 0 && n < (int)_ranges.size(), 0);
   return _ranges[n]._min;
@@ -237,7 +237,7 @@ get_min(int n) const {
  * Returns the maximum value defined by the nth component.
  */
 template <class NUM>
-INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
+INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
 get_max(int n) const {
   nassertr(n >= 0 && n < (int)_ranges.size(), 0);
   return _ranges[n]._max;

direct/src/dcparser/dcbase.h

@@ -61,7 +61,6 @@
 #endif
 
 #define INLINE inline
-#define TYPENAME typename
 
 // These symbols are used within the Panda environment for exporting classes
 // and functions to the scripting language.  They're largely meaningless if

dtool/src/dtoolbase/dtoolbase_cc.h

@@ -37,7 +37,6 @@
 
 #define INLINE inline
 #define ALWAYS_INLINE inline
-#define TYPENAME typename
 #define MOVE(x) x
 
 #define EXPORT_TEMPLATE_CLASS(expcl, exptp, classname)
@@ -78,8 +77,6 @@ typedef int ios_seekdir;
 #include <utility>
 #include <algorithm>
 
-#define TYPENAME typename
-
 #ifndef HAVE_IOS_TYPEDEFS
 typedef int ios_openmode;
 typedef int ios_fmtflags;

dtool/src/dtoolbase/epvector.h

@@ -39,7 +39,7 @@ class epvector : public vector<Type, Eigen::aligned_allocator<Type> > {
 public:
   typedef Eigen::aligned_allocator<Type> allocator;
   typedef vector<Type, allocator> base_class;
-  typedef TYPENAME base_class::size_type size_type;
+  typedef typename base_class::size_type size_type;
 
   epvector(TypeHandle type_handle = pvector_type_handle) : base_class(allocator()) { }
   epvector(const epvector<Type> &copy) : base_class(copy) { }

dtool/src/dtoolbase/pallocator.T

@@ -20,7 +20,7 @@ pallocator_single(TypeHandle type_handle) noexcept :
 
 template<class Type>
 INLINE Type *pallocator_single<Type>::
-allocate(TYPENAME pallocator_single<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
+allocate(typename pallocator_single<Type>::size_type n, typename allocator<void>::const_pointer) {
   TAU_PROFILE("pallocator_single:allocate()", " ", TAU_USER);
   // This doesn't support allocating arrays.
   assert(n == 1);
@@ -30,7 +30,7 @@ allocate(TYPENAME pallocator_single<Type>::size_type n, TYPENAME allocator<void>
 
 template<class Type>
 INLINE void pallocator_single<Type>::
-deallocate(TYPENAME pallocator_single<Type>::pointer p, TYPENAME pallocator_single<Type>::size_type) {
+deallocate(typename pallocator_single<Type>::pointer p, typename pallocator_single<Type>::size_type) {
   TAU_PROFILE("pallocator_single:deallocate()", " ", TAU_USER);
   StaticDeletedChain<Type>::deallocate(p, _type_handle);
 }
@@ -44,13 +44,13 @@ pallocator_array(TypeHandle type_handle) noexcept :
 
 template<class Type>
 INLINE Type *pallocator_array<Type>::
-allocate(TYPENAME pallocator_array<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
-  return (TYPENAME pallocator_array<Type>::pointer)
+allocate(typename pallocator_array<Type>::size_type n, typename allocator<void>::const_pointer) {
+  return (typename pallocator_array<Type>::pointer)
     ASSUME_ALIGNED(_type_handle.allocate_array(n * sizeof(Type)), MEMORY_HOOK_ALIGNMENT);
 }
 
 template<class Type>
 INLINE void pallocator_array<Type>::
-deallocate(TYPENAME pallocator_array<Type>::pointer p, TYPENAME pallocator_array<Type>::size_type) {
+deallocate(typename pallocator_array<Type>::pointer p, typename pallocator_array<Type>::size_type) {
   _type_handle.deallocate_array((void *)p);
 }

dtool/src/dtoolbase/pallocator.h

@@ -48,11 +48,11 @@ class pallocator_single : public allocator<Type> {
 public:
   // Nowadays we cannot implicitly inherit typedefs from base classes in a
   // template class; we must explicitly copy them here.
-  typedef TYPENAME allocator<Type>::pointer pointer;
-  typedef TYPENAME allocator<Type>::reference reference;
-  typedef TYPENAME allocator<Type>::const_pointer const_pointer;
-  typedef TYPENAME allocator<Type>::const_reference const_reference;
-  typedef TYPENAME allocator<Type>::size_type size_type;
+  typedef typename allocator<Type>::pointer pointer;
+  typedef typename allocator<Type>::reference reference;
+  typedef typename allocator<Type>::const_pointer const_pointer;
+  typedef typename allocator<Type>::const_reference const_reference;
+  typedef typename allocator<Type>::size_type size_type;
 
   INLINE pallocator_single(TypeHandle type_handle) noexcept;
 
@@ -77,11 +77,11 @@ class pallocator_array : public allocator<Type> {
 public:
   // Nowadays we cannot implicitly inherit typedefs from base classes in a
   // template class; we must explicitly copy them here.
-  typedef TYPENAME allocator<Type>::pointer pointer;
-  typedef TYPENAME allocator<Type>::reference reference;
-  typedef TYPENAME allocator<Type>::const_pointer const_pointer;
-  typedef TYPENAME allocator<Type>::const_reference const_reference;
-  typedef TYPENAME allocator<Type>::size_type size_type;
+  typedef typename allocator<Type>::pointer pointer;
+  typedef typename allocator<Type>::reference reference;
+  typedef typename allocator<Type>::const_pointer const_pointer;
+  typedef typename allocator<Type>::const_reference const_reference;
+  typedef typename allocator<Type>::size_type size_type;
 
   INLINE pallocator_array(TypeHandle type_handle = TypeHandle::none()) noexcept;
 

dtool/src/dtoolbase/pdeque.h

@@ -37,7 +37,7 @@ template<class Type>
 class pdeque : public deque<Type, pallocator_array<Type> > {
 public:
   typedef pallocator_array<Type> allocator;
-  typedef TYPENAME deque<Type, allocator>::size_type size_type;
+  typedef typename deque<Type, allocator>::size_type size_type;
   pdeque(TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(allocator(type_handle)) { }
   pdeque(size_type n, TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(n, Type(), allocator(type_handle)) { }
   pdeque(size_type n, const Type &value, TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(n, value, allocator(type_handle)) { }

dtool/src/dtoolbase/plist.h

@@ -38,15 +38,15 @@ class plist : public list<Type, pallocator_single<Type> > {
 public:
   typedef pallocator_single<Type> allocator;
   typedef list<Type, allocator> base_class;
-  typedef TYPENAME base_class::size_type size_type;
+  typedef typename base_class::size_type size_type;
   plist(TypeHandle type_handle = plist_type_handle) : base_class(allocator(type_handle)) { }
   plist(size_type n, TypeHandle type_handle = plist_type_handle) : base_class(n, Type(), allocator(type_handle)) { }
   plist(size_type n, const Type &value, TypeHandle type_handle = plist_type_handle) : base_class(n, value, allocator(type_handle)) { }
 
-  typedef TYPENAME base_class::iterator iterator;
-  typedef TYPENAME base_class::const_iterator const_iterator;
-  typedef TYPENAME base_class::reverse_iterator reverse_iterator;
-  typedef TYPENAME base_class::const_reverse_iterator const_reverse_iterator;
+  typedef typename base_class::iterator iterator;
+  typedef typename base_class::const_iterator const_iterator;
+  typedef typename base_class::reverse_iterator reverse_iterator;
+  typedef typename base_class::const_reverse_iterator const_reverse_iterator;
 
   // This exists because libc++'s remove implementation has a bug with Panda's
   // allocator class.

dtool/src/dtoolbase/pmap.h

@@ -58,33 +58,33 @@ public:
   pmap(const Compare &comp, TypeHandle type_handle = pmap_type_handle) : base_class(comp, allocator(type_handle)) { }
 
 #ifdef USE_TAU
-  TYPENAME base_class::mapped_type &
-  operator [] (const TYPENAME base_class::key_type &k) {
+  typename base_class::mapped_type &
+  operator [] (const typename base_class::key_type &k) {
     TAU_PROFILE("pmap::operator [] (const key_type &)", " ", TAU_USER);
     return base_class::operator [] (k);
   }
 
-  std::pair<TYPENAME base_class::iterator, bool>
-  insert(const TYPENAME base_class::value_type &x) {
+  std::pair<typename base_class::iterator, bool>
+  insert(const typename base_class::value_type &x) {
     TAU_PROFILE("pmap::insert(const value_type &)", " ", TAU_USER);
     return base_class::insert(x);
   }
 
-  TYPENAME base_class::iterator
-  insert(TYPENAME base_class::iterator position,
-         const TYPENAME base_class::value_type &x) {
+  typename base_class::iterator
+  insert(typename base_class::iterator position,
+         const typename base_class::value_type &x) {
     TAU_PROFILE("pmap::insert(iterator, const value_type &)", " ", TAU_USER);
     return base_class::insert(position, x);
   }
 
   void
-  erase(TYPENAME base_class::iterator position) {
+  erase(typename base_class::iterator position) {
     TAU_PROFILE("pmap::erase(iterator)", " ", TAU_USER);
     base_class::erase(position);
   }
 
-  TYPENAME base_class::size_type
-  erase(const TYPENAME base_class::key_type &x) {
+  typename base_class::size_type
+  erase(const typename base_class::key_type &x) {
     TAU_PROFILE("pmap::erase(const key_type &)", " ", TAU_USER);
     return base_class::erase(x);
   }
@@ -95,14 +95,14 @@ public:
     base_class::clear();
   }
 
-  TYPENAME base_class::iterator
-  find(const TYPENAME base_class::key_type &x) {
+  typename base_class::iterator
+  find(const typename base_class::key_type &x) {
     TAU_PROFILE("pmap::find(const key_type &)", " ", TAU_USER);
     return base_class::find(x);
   }
 
-  TYPENAME base_class::const_iterator
-  find(const TYPENAME base_class::key_type &x) const {
+  typename base_class::const_iterator
+  find(const typename base_class::key_type &x) const {
     TAU_PROFILE("pmap::find(const key_type &)", " ", TAU_USER);
     return base_class::find(x);
   }

dtool/src/dtoolbase/pset.h

@@ -57,27 +57,27 @@ public:
   pset(const Compare &comp, TypeHandle type_handle = pset_type_handle) : base_class(comp, type_handle) { }
 
 #ifdef USE_TAU
-  std::pair<TYPENAME base_class::iterator, bool>
-  insert(const TYPENAME base_class::value_type &x) {
+  std::pair<typename base_class::iterator, bool>
+  insert(const typename base_class::value_type &x) {
     TAU_PROFILE("pset::insert(const value_type &)", " ", TAU_USER);
     return base_class::insert(x);
   }
 
-  TYPENAME base_class::iterator
-  insert(TYPENAME base_class::iterator position,
-         const TYPENAME base_class::value_type &x) {
+  typename base_class::iterator
+  insert(typename base_class::iterator position,
+         const typename base_class::value_type &x) {
     TAU_PROFILE("pset::insert(iterator, const value_type &)", " ", TAU_USER);
     return base_class::insert(position, x);
   }
 
   void
-  erase(TYPENAME base_class::iterator position) {
+  erase(typename base_class::iterator position) {
     TAU_PROFILE("pset::erase(iterator)", " ", TAU_USER);
     base_class::erase(position);
   }
 
-  TYPENAME base_class::size_type
-  erase(const TYPENAME base_class::key_type &x) {
+  typename base_class::size_type
+  erase(const typename base_class::key_type &x) {
     TAU_PROFILE("pset::erase(const key_type &)", " ", TAU_USER);
     return base_class::erase(x);
   }
@@ -88,14 +88,14 @@ public:
     base_class::clear();
   }
 
-  TYPENAME base_class::iterator
-  find(const TYPENAME base_class::key_type &x) {
+  typename base_class::iterator
+  find(const typename base_class::key_type &x) {
     TAU_PROFILE("pset::find(x)", " ", TAU_USER);
     return base_class::find(x);
   }
 
-  TYPENAME base_class::const_iterator
-  find(const TYPENAME base_class::key_type &x) const {
+  typename base_class::const_iterator
+  find(const typename base_class::key_type &x) const {
     TAU_PROFILE("pset::find(x)", " ", TAU_USER);
     return base_class::find(x);
   }

dtool/src/interrogatedb/interrogate_datafile.I

@@ -19,7 +19,7 @@ template<class Element>
 void
 idf_output_vector(ostream &out, const std::vector<Element> &vec) {
   out << vec.size() << " ";
-  TYPENAME std::vector<Element>::const_iterator vi;
+  typename std::vector<Element>::const_iterator vi;
   for (vi = vec.begin(); vi != vec.end(); ++vi) {
     out << (*vi) << " ";
   }

panda/src/chan/animChannel.I

@@ -71,7 +71,7 @@ INLINE AnimChannel<SwitchType>::
  */
 template<class SwitchType>
 void AnimChannel<SwitchType>::
-get_value(int, TYPENAME AnimChannel<SwitchType>::ValueType &) {
+get_value(int, typename AnimChannel<SwitchType>::ValueType &) {
 }
 #endif
 

panda/src/chan/animChannel.h

@@ -33,7 +33,7 @@ protected:
   INLINE AnimChannel(const string &name = "");
   INLINE AnimChannel(AnimGroup *parent, const AnimChannel &copy);
 public:
-  typedef TYPENAME SwitchType::ValueType ValueType;
+  typedef typename SwitchType::ValueType ValueType;
 
   INLINE AnimChannel(AnimGroup *parent, const string &name);
   INLINE ~AnimChannel();

panda/src/chan/animChannelFixed.h

@@ -28,7 +28,7 @@
 template<class SwitchType>
 class AnimChannelFixed : public AnimChannel<SwitchType> {
 public:
-  typedef TYPENAME AnimChannel<SwitchType>::ValueType ValueType;
+  typedef typename AnimChannel<SwitchType>::ValueType ValueType;
 
 protected:
   INLINE AnimChannelFixed(AnimGroup *parent, const AnimChannelFixed<SwitchType> &copy);

panda/src/chan/movingPart.h

@@ -26,7 +26,7 @@
 template<class SwitchType>
 class MovingPart : public MovingPartBase {
 public:
-  typedef TYPENAME SwitchType::ValueType ValueType;
+  typedef typename SwitchType::ValueType ValueType;
   typedef AnimChannel<SwitchType> ChannelType;
 
 protected:

panda/src/egg/eggMorphList.I

@@ -97,7 +97,7 @@ compare_to(const EggMorphList<MorphType> &other, double threshold) const {
  *
  */
 template<class MorphType>
-INLINE TYPENAME EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
+INLINE typename EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
 begin() {
   return _morphs.begin();
 }
@@ -106,7 +106,7 @@ begin() {
  *
  */
 template<class MorphType>
-INLINE TYPENAME EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
+INLINE typename EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
 begin() const {
   return _morphs.begin();
 }
@@ -115,7 +115,7 @@ begin() const {
  *
  */
 template<class MorphType>
-INLINE TYPENAME EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
+INLINE typename EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
 end() {
   return _morphs.end();
 }
@@ -124,7 +124,7 @@ end() {
  *
  */
 template<class MorphType>
-INLINE TYPENAME EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
+INLINE typename EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
 end() const {
   return _morphs.end();
 }
@@ -133,7 +133,7 @@ end() const {
  *
  */
 template<class MorphType>
-INLINE TYPENAME EggMorphList<MorphType>::size_type EggMorphList<MorphType>::
+INLINE typename EggMorphList<MorphType>::size_type EggMorphList<MorphType>::
 size() const {
   return _morphs.size();
 }
@@ -155,10 +155,10 @@ empty() const {
  * to *be* a set, but we cannot export STL sets from a Windows DLL.
  */
 template<class MorphType>
-pair<TYPENAME EggMorphList<MorphType>::iterator, bool> EggMorphList<MorphType>::
+pair<typename EggMorphList<MorphType>::iterator, bool> EggMorphList<MorphType>::
 insert(const MorphType &value) {
   pair<iterator, bool> result;
-  TYPENAME Morphs::iterator mi;
+  typename Morphs::iterator mi;
   for (mi = _morphs.begin(); mi != _morphs.end(); ++mi) {
     if ((*mi) == value) {
       // This value is already present.

panda/src/egg/eggMorphList.h

@@ -31,9 +31,9 @@ private:
   typedef epvector<MorphType> Morphs;
 
 public:
-  typedef TYPENAME Morphs::iterator iterator;
-  typedef TYPENAME Morphs::const_iterator const_iterator;
-  typedef TYPENAME Morphs::size_type size_type;
+  typedef typename Morphs::iterator iterator;
+  typedef typename Morphs::const_iterator const_iterator;
+  typedef typename Morphs::size_type size_type;
 
   INLINE EggMorphList();
   INLINE EggMorphList(const EggMorphList<MorphType> &copy);

panda/src/express/nodePointerTo.I

@@ -62,7 +62,7 @@ operator = (NodePointerTo<T> &&from) noexcept {
  *
  */
 template<class T>
-INLINE TYPENAME NodePointerTo<T>::To &NodePointerTo<T>::
+INLINE typename NodePointerTo<T>::To &NodePointerTo<T>::
 operator *() const {
   return *((To *)(this->_void_ptr));
 }
@@ -73,7 +73,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE TYPENAME NodePointerTo<T>::To *NodePointerTo<T>::
+INLINE typename NodePointerTo<T>::To *NodePointerTo<T>::
 operator -> () const {
   return (To *)(this->_void_ptr);
 }
@@ -99,7 +99,7 @@ operator T *() const {
  * around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE TYPENAME NodePointerTo<T>::To *NodePointerTo<T>::
+INLINE typename NodePointerTo<T>::To *NodePointerTo<T>::
 p() const {
   return (To *)(this->_void_ptr);
 }
@@ -135,8 +135,8 @@ operator = (const NodePointerTo<T> &copy) {
  */
 template<class T>
 INLINE NodeConstPointerTo<T>::
-NodeConstPointerTo(const TYPENAME NodeConstPointerTo<T>::To *ptr) :
-  NodePointerToBase<T>((TYPENAME NodeConstPointerTo<T>::To *)ptr)
+NodeConstPointerTo(const typename NodeConstPointerTo<T>::To *ptr) :
+  NodePointerToBase<T>((typename NodeConstPointerTo<T>::To *)ptr)
 {
 }
 #endif  // CPPPARSER
@@ -218,7 +218,7 @@ operator = (NodeConstPointerTo<T> &&from) noexcept {
  *
  */
 template<class T>
-INLINE const TYPENAME NodeConstPointerTo<T>::To &NodeConstPointerTo<T>::
+INLINE const typename NodeConstPointerTo<T>::To &NodeConstPointerTo<T>::
 operator *() const {
   return *((To *)(this->_void_ptr));
 }
@@ -229,7 +229,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE const TYPENAME NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
+INLINE const typename NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
 operator -> () const {
   return (To *)(this->_void_ptr);
 }
@@ -256,7 +256,7 @@ operator const T * () const {
  * work around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE const TYPENAME NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
+INLINE const typename NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
 p() const {
   return (To *)(this->_void_ptr);
 }

panda/src/express/nodePointerTo.h

@@ -28,7 +28,7 @@ public:
   // By hiding this template from interrogate, we improve compile-time speed
   // and memory utilization.
 #ifndef CPPPARSER
-  typedef TYPENAME NodePointerToBase<T>::To To;
+  typedef typename NodePointerToBase<T>::To To;
   INLINE NodePointerTo(To *ptr = nullptr);
   INLINE NodePointerTo(const NodePointerTo<T> &copy);
   INLINE NodePointerTo(NodePointerTo<T> &&from) noexcept;
@@ -59,7 +59,7 @@ public:
   // By hiding this template from interrogate, we improve compile-time speed
   // and memory utilization.
 #ifndef CPPPARSER
-  typedef TYPENAME NodePointerToBase<T>::To To;
+  typedef typename NodePointerToBase<T>::To To;
   INLINE NodeConstPointerTo(const To *ptr = nullptr);
   INLINE NodeConstPointerTo(const NodePointerTo<T> &copy);
   INLINE NodeConstPointerTo(const NodeConstPointerTo<T> &copy);

panda/src/express/ordered_vector.I

@@ -37,7 +37,7 @@ ordered_vector(const Compare &compare, TypeHandle type_handle) :
  * Returns the iterator that marks the first element in the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
 begin() {
   return _vector.begin();
 }
@@ -46,7 +46,7 @@ begin() {
  * Returns the iterator that marks the end of the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
 end() {
   return _vector.end();
 }
@@ -56,7 +56,7 @@ end() {
  * when viewed in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 rbegin() {
   return _vector.rbegin();
 }
@@ -66,7 +66,7 @@ rbegin() {
  * in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 rend() {
   return _vector.rend();
 }
@@ -75,7 +75,7 @@ rend() {
  * Returns the iterator that marks the first element in the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
 begin() const {
   return _vector.begin();
 }
@@ -84,7 +84,7 @@ begin() const {
  * Returns the iterator that marks the end of the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
 end() const {
   return _vector.end();
 }
@@ -94,7 +94,7 @@ end() const {
  * when viewed in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 rbegin() const {
   return _vector.rbegin();
 }
@@ -104,7 +104,7 @@ rbegin() const {
  * in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 rend() const {
   return _vector.rend();
 }
@@ -113,7 +113,7 @@ rend() const {
  * Returns the iterator that marks the first element in the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
 cbegin() const {
   return _vector.begin();
 }
@@ -122,7 +122,7 @@ cbegin() const {
  * Returns the iterator that marks the end of the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
 cend() const {
   return _vector.end();
 }
@@ -132,7 +132,7 @@ cend() const {
  * when viewed in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 crbegin() const {
   return _vector.rbegin();
 }
@@ -142,7 +142,7 @@ crbegin() const {
  * in reverse order.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
 crend() const {
   return _vector.rend();
 }
@@ -151,8 +151,8 @@ crend() const {
  * Returns the nth element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
-operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
+INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
+operator [] (typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
   return _vector[n];
 }
 
@@ -160,8 +160,8 @@ operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
  * Returns the nth element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
-operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
+operator [] (typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
   return _vector[n];
 }
 
@@ -169,7 +169,7 @@ operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
  * Returns a reference to the first element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
 front() {
 #ifdef _DEBUG
   assert(!_vector.empty());
@@ -181,7 +181,7 @@ front() {
  * Returns a const reference to the first element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
 front() const {
 #ifdef _DEBUG
   assert(!_vector.empty());
@@ -193,7 +193,7 @@ front() const {
  * Returns a reference to the first element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
 back() {
 #ifdef _DEBUG
   assert(!_vector.empty());
@@ -205,7 +205,7 @@ back() {
  * Returns a const reference to the last element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
 back() const {
 #ifdef _DEBUG
   assert(!_vector.empty());
@@ -217,7 +217,7 @@ back() const {
  * Returns the number of elements in the ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
 size() const {
   return _vector.size();
 }
@@ -227,7 +227,7 @@ size() const {
  * ordered vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
 max_size() const {
   return _vector.max_size();
 }
@@ -312,8 +312,8 @@ operator >= (const ordered_vector<Key, Compare, Vector> &other) const {
  * componet is true if the insert operation has taken place.
  */
 template<class Key, class Compare, class Vector>
-INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, bool> ordered_vector<Key, Compare, Vector>::
-insert_unique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
+INLINE pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, bool> ordered_vector<Key, Compare, Vector>::
+insert_unique(const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
   TAU_PROFILE("ordered_vector::insert_unique(const value_type &)", " ", TAU_USER);
   ITERATOR position = find_insert_position(begin(), end(), key);
 #ifdef NDEBUG
@@ -341,8 +341,8 @@ insert_unique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &k
  * The return value is the iterator referencing the new element.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-insert_nonunique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+insert_nonunique(const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
   TAU_PROFILE("ordered_vector::insert_nonunique(const value_type &)", " ", TAU_USER);
   ITERATOR position = find_insert_position(begin(), end(), key);
   nassertr(position >= begin() && position <= end(), end());
@@ -358,9 +358,9 @@ insert_nonunique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE
  * sorting position; no checks are made.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-insert_unverified(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position,
-                  const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+insert_unverified(typename ordered_vector<Key, Compare, Vector>::ITERATOR position,
+                  const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
   TAU_PROFILE("ordered_vector::insert_unverified(iterator, const value_type &)", " ", TAU_USER);
   ITERATOR result = _vector.insert(position, key);
   return result;
@@ -371,8 +371,8 @@ insert_unverified(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR positi
  * sequential iterator.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+erase(typename ordered_vector<Key, Compare, Vector>::ITERATOR position) {
   TAU_PROFILE("ordered_vector::erase(iterator)", " ", TAU_USER);
   SIZE_TYPE count = position - begin();
   _vector.erase(position);
@@ -384,8 +384,8 @@ erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position) {
  * elements removed.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
-erase(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
+erase(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::erase(const key_type &)", " ", TAU_USER);
   pair<ITERATOR, ITERATOR> result = equal_range(key);
   SIZE_TYPE count = result.second - result.first;
@@ -398,8 +398,8 @@ erase(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
  */
 template<class Key, class Compare, class Vector>
 INLINE void ordered_vector<Key, Compare, Vector>::
-erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR first,
-      TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR last) {
+erase(typename ordered_vector<Key, Compare, Vector>::ITERATOR first,
+      typename ordered_vector<Key, Compare, Vector>::ITERATOR last) {
   TAU_PROFILE("ordered_vector::erase(iterator, iterator)", " ", TAU_USER);
   _vector.erase(first, last);
 }
@@ -420,8 +420,8 @@ clear() {
  * matching the key, the particular iterator returned is not defined.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+find(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
   return nci(r_find(begin(), end(), end(), key));
 }
@@ -432,8 +432,8 @@ find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
  * matching the key, the particular iterator returned is not defined.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+find(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
   return r_find(begin(), end(), end(), key);
 }
@@ -452,8 +452,8 @@ find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
  * not necessarily the converse.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+find_particular(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
   return nci(r_find_particular(begin(), end(), end(), key));
 }
@@ -469,8 +469,8 @@ find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &k
  * is not defined.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+find_particular(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
   return r_find_particular(begin(), end(), end(), key);
 }
@@ -480,7 +480,7 @@ find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &k
  * the vector.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
+INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
 count(const key_type &key) const {
   TAU_PROFILE("ordered_vector::count(const key_type &)", " ", TAU_USER);
   return r_count(begin(), end(), key);
@@ -491,8 +491,8 @@ count(const key_type &key) const {
  * all elements are less than key.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+lower_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
   return nci(r_lower_bound(begin(), end(), key));
 }
@@ -502,8 +502,8 @@ lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
  * all elements are less than key.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+lower_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
   return r_lower_bound(begin(), end(), key);
 }
@@ -513,8 +513,8 @@ lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
  * element is greater than key.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+upper_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
   return nci(r_upper_bound(begin(), end(), key));
 }
@@ -524,8 +524,8 @@ upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
  * element is greater than key.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+upper_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
   return r_upper_bound(begin(), end(), key);
 }
@@ -534,20 +534,20 @@ upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
  * Returns the pair (lower_bound(key), upper_bound(key)).
  */
 template<class Key, class Compare, class Vector>
-INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR> ordered_vector<Key, Compare, Vector>::
-equal_range(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, typename ordered_vector<Key, Compare, Vector>::ITERATOR> ordered_vector<Key, Compare, Vector>::
+equal_range(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
-  pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> result;
+  pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> result;
   result = r_equal_range(begin(), end(), key);
-  return pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR>(nci(result.first), nci(result.second));
+  return pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, typename ordered_vector<Key, Compare, Vector>::ITERATOR>(nci(result.first), nci(result.second));
 }
 
 /**
  * Returns the pair (lower_bound(key), upper_bound(key)).
  */
 template<class Key, class Compare, class Vector>
-INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
-equal_range(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+INLINE pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
+equal_range(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
   return r_equal_range(begin(), end(), key);
 }
@@ -569,7 +569,7 @@ swap(ordered_vector<Key, Compare, Vector> &copy) {
  */
 template<class Key, class Compare, class Vector>
 INLINE void ordered_vector<Key, Compare, Vector>::
-reserve(TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
+reserve(typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
   TAU_PROFILE("ordered_vector::reserve(size_type)", " ", TAU_USER);
   _vector.reserve(n);
 }
@@ -666,8 +666,8 @@ resize(SIZE_TYPE n, const VALUE_TYPE &value) {
  * const flavors of some of these methods.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-nci(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+nci(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
   return begin() + (i - begin());
 }
 
@@ -676,10 +676,10 @@ nci(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
  * indicated key, and returns the corresponding iterator.
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-find_insert_position(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR first,
-                     TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR last,
-                     const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+find_insert_position(typename ordered_vector<Key, Compare, Vector>::ITERATOR first,
+                     typename ordered_vector<Key, Compare, Vector>::ITERATOR last,
+                     const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   ITERATOR result = r_find_insert_position(first, last, key);
   return result;
 }
@@ -708,9 +708,9 @@ ov_set(const Compare &compare, TypeHandle type_handle) :
  * Maps to insert_unique().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ov_set<Key, Compare, Vector>::ITERATOR ov_set<Key, Compare, Vector>::
-insert(TYPENAME ov_set<Key, Compare, Vector>::ITERATOR position,
-       const TYPENAME ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
+typename ov_set<Key, Compare, Vector>::ITERATOR ov_set<Key, Compare, Vector>::
+insert(typename ov_set<Key, Compare, Vector>::ITERATOR position,
+       const typename ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare, Vector>::insert_unique(position, key);
 }
 
@@ -718,8 +718,8 @@ insert(TYPENAME ov_set<Key, Compare, Vector>::ITERATOR position,
  * Maps to insert_unique().
  */
 template<class Key, class Compare, class Vector>
-INLINE pair<TYPENAME ov_set<Key, Compare, Vector>::ITERATOR, bool> ov_set<Key, Compare, Vector>::
-insert(const TYPENAME ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
+INLINE pair<typename ov_set<Key, Compare, Vector>::ITERATOR, bool> ov_set<Key, Compare, Vector>::
+insert(const typename ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare, Vector>::insert_unique(key);
 }
 
@@ -765,9 +765,9 @@ ov_multiset(const Compare &compare, TypeHandle type_handle) :
  * Maps to insert_nonunique().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
-insert(TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR position,
-       const TYPENAME ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
+typename ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
+insert(typename ov_multiset<Key, Compare, Vector>::ITERATOR position,
+       const typename ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare, Vector>::insert_nonunique(position, key);
 }
 
@@ -775,8 +775,8 @@ insert(TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR position,
  * Maps to insert_nonunique().
  */
 template<class Key, class Compare, class Vector>
-INLINE TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
-insert(const TYPENAME ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
+INLINE typename ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
+insert(const typename ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare, Vector>::insert_nonunique(key);
 }
 

panda/src/express/ordered_vector.T

@@ -22,9 +22,9 @@
  * iterator referencing the original value is returned.
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-insert_unique(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position, 
-              const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
+typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+insert_unique(typename ordered_vector<Key, Compare, Vector>::ITERATOR position, 
+              const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
   TAU_PROFILE("ordered_vector::insert_unique(iterator, const value_type &)", " ", TAU_USER);
   if (position != end()) {
     // If we're not inserting at the end, the element we're
@@ -67,9 +67,9 @@ insert_unique(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position,
  * same key to be inserted.
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-insert_nonunique(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position, 
-                 const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
+typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+insert_nonunique(typename ordered_vector<Key, Compare, Vector>::ITERATOR position, 
+                 const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
   TAU_PROFILE("ordered_vector::insert_nonunique(iterator, const value_type &)", " ", TAU_USER);
   if (position != end()) {
     // If we're not inserting at the end, the element we're
@@ -145,10 +145,10 @@ verify_list_nonunique() const {
  * The recursive implementation of find_insert_position().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
-r_find_insert_position(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR first,
-                       TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR last,
-                       const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
+typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
+r_find_insert_position(typename ordered_vector<Key, Compare, Vector>::ITERATOR first,
+                       typename ordered_vector<Key, Compare, Vector>::ITERATOR last,
+                       const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
   if (first == last) {
     // The list is empty; the insert position is the last of the list.
     return last;
@@ -171,11 +171,11 @@ r_find_insert_position(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR f
  * The recursive implementation of find().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-r_find(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-       TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-       TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
-       const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+r_find(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+       typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+       typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
+       const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
@@ -202,11 +202,11 @@ r_find(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
  * The recursive implementation of find_particular().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-r_find_particular(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-                  TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-                  TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
-                  const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+r_find_particular(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+                  typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+                  typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
+                  const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
@@ -253,10 +253,10 @@ r_find_particular(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR
  * The recursive implementation of count().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
-r_count(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-        TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-        const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
+r_count(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+        typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+        const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
 
   if (first == last) {
     // The list is empty; the key is not on the list.
@@ -286,10 +286,10 @@ r_count(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
  * The recursive implementation of lower_bound().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-r_lower_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-              TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-              const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+r_lower_bound(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+              typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+              const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
@@ -317,10 +317,10 @@ r_lower_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR firs
  * The recursive implementation of upper_bound().
  */
 template<class Key, class Compare, class Vector>
-TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
-r_upper_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-              TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-              const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
+r_upper_bound(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+              typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+              const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
@@ -348,11 +348,11 @@ r_upper_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR firs
  * The recursive implementation of equal_range().
  */
 template<class Key, class Compare, class Vector>
-pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
-r_equal_range(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
-              TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
-              const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
-  typedef pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> pair_type;
+pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
+r_equal_range(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
+              typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
+              const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
+  typedef pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> pair_type;
 
   if (first == last) {
     // The list is empty; the key is not on the list.

panda/src/express/ordered_vector.h

@@ -105,13 +105,13 @@ public:
   // Be careful when using the non-const iterators that you do not disturb the
   // sorted order of the vector, or that if you do, you call sort() when you
   // are done.
-  typedef TYPENAME Vector::iterator ITERATOR;
-  typedef TYPENAME Vector::const_iterator CONST_ITERATOR;
-  typedef TYPENAME Vector::reverse_iterator REVERSE_ITERATOR;
-  typedef TYPENAME Vector::const_reverse_iterator CONST_REVERSE_ITERATOR;
+  typedef typename Vector::iterator ITERATOR;
+  typedef typename Vector::const_iterator CONST_ITERATOR;
+  typedef typename Vector::reverse_iterator REVERSE_ITERATOR;
+  typedef typename Vector::const_reverse_iterator CONST_REVERSE_ITERATOR;
 
-  typedef TYPENAME Vector::difference_type DIFFERENCE_TYPE;
-  typedef TYPENAME Vector::size_type SIZE_TYPE;
+  typedef typename Vector::difference_type DIFFERENCE_TYPE;
+  typedef typename Vector::size_type SIZE_TYPE;
 
   // Since the #define symbols do not actually expand to the correct names, we
   // have to re-typedef them so callers can reference them by their correct,
@@ -268,8 +268,8 @@ private:
 template<class Key, class Compare = less<Key>, class Vector = pvector<Key> >
 class ov_set : public ordered_vector<Key, Compare, Vector> {
 public:
-  typedef TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
-  typedef TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
+  typedef typename ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
+  typedef typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
 
   INLINE ov_set(TypeHandle type_handle = ov_set_type_handle);
   INLINE ov_set(const Compare &compare,
@@ -289,8 +289,8 @@ public:
 template<class Key, class Compare = less<Key>, class Vector = pvector<Key> >
 class ov_multiset : public ordered_vector<Key, Compare, Vector> {
 public:
-  typedef TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
-  typedef TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
+  typedef typename ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
+  typedef typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
 
   INLINE ov_multiset(TypeHandle type_handle = ov_set_type_handle);
   INLINE ov_multiset(const Compare &compare,

panda/src/express/pointerTo.I

@@ -53,7 +53,7 @@ operator = (PointerTo<T> &&from) noexcept {
  *
  */
 template<class T>
-constexpr TYPENAME PointerTo<T>::To &PointerTo<T>::
+constexpr typename PointerTo<T>::To &PointerTo<T>::
 operator *() const noexcept {
   return *((To *)(this->_void_ptr));
 }
@@ -62,7 +62,7 @@ operator *() const noexcept {
  *
  */
 template<class T>
-constexpr TYPENAME PointerTo<T>::To *PointerTo<T>::
+constexpr typename PointerTo<T>::To *PointerTo<T>::
 operator -> () const noexcept {
   return (To *)(this->_void_ptr);
 }
@@ -97,7 +97,7 @@ cheat() {
  * compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-constexpr TYPENAME PointerTo<T>::To *PointerTo<T>::
+constexpr typename PointerTo<T>::To *PointerTo<T>::
 p() const noexcept {
   return (To *)(this->_void_ptr);
 }
@@ -127,8 +127,8 @@ operator = (const PointerTo<T> &copy) {
  */
 template<class T>
 ALWAYS_INLINE ConstPointerTo<T>::
-ConstPointerTo(const TYPENAME ConstPointerTo<T>::To *ptr) noexcept :
-  PointerToBase<T>((TYPENAME ConstPointerTo<T>::To *)ptr)
+ConstPointerTo(const typename ConstPointerTo<T>::To *ptr) noexcept :
+  PointerToBase<T>((typename ConstPointerTo<T>::To *)ptr)
 {
 }
 
@@ -196,7 +196,7 @@ operator = (ConstPointerTo<T> &&from) noexcept {
  *
  */
 template<class T>
-constexpr const TYPENAME ConstPointerTo<T>::To &ConstPointerTo<T>::
+constexpr const typename ConstPointerTo<T>::To &ConstPointerTo<T>::
 operator *() const noexcept {
   return *((To *)(this->_void_ptr));
 }
@@ -205,7 +205,7 @@ operator *() const noexcept {
  *
  */
 template<class T>
-constexpr const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
+constexpr const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
 operator -> () const noexcept {
   return (To *)(this->_void_ptr);
 }
@@ -240,7 +240,7 @@ cheat() {
  * around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-constexpr const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
+constexpr const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
 p() const noexcept {
   return (To *)(this->_void_ptr);
 }

panda/src/express/pointerTo.h

@@ -68,7 +68,7 @@
 template <class T>
 class PointerTo : public PointerToBase<T> {
 public:
-  typedef TYPENAME PointerToBase<T>::To To;
+  typedef typename PointerToBase<T>::To To;
 PUBLISHED:
   ALWAYS_INLINE constexpr PointerTo() noexcept = default;
   ALWAYS_INLINE PointerTo(To *ptr) noexcept;
@@ -129,7 +129,7 @@ PUBLISHED:
 template <class T>
 class ConstPointerTo : public PointerToBase<T> {
 public:
-  typedef TYPENAME PointerToBase<T>::To To;
+  typedef typename PointerToBase<T>::To To;
 PUBLISHED:
   ALWAYS_INLINE constexpr ConstPointerTo() noexcept = default;
   ALWAYS_INLINE ConstPointerTo(const To *ptr) noexcept;

panda/src/express/pointerToArray.I

@@ -105,7 +105,7 @@ PointerToArray(pvector<Element> &&from, TypeHandle type_handle) :
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
 begin() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.begin();
@@ -117,7 +117,7 @@ begin() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
 end() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.begin();
@@ -129,7 +129,7 @@ end() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
 rbegin() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.rbegin();
@@ -141,7 +141,7 @@ rbegin() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
 rend() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.rbegin();
@@ -153,7 +153,7 @@ rend() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
 size() const {
   return ((this->_void_ptr) == nullptr) ? 0 : ((To *)(this->_void_ptr))->size();
 }
@@ -162,7 +162,7 @@ size() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
 max_size() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -184,7 +184,7 @@ empty() const {
  */
 template<class Element>
 INLINE void PointerToArray<Element>::
-reserve(TYPENAME PointerToArray<Element>::size_type n) {
+reserve(typename PointerToArray<Element>::size_type n) {
   if ((this->_void_ptr) == nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
   }
@@ -196,7 +196,7 @@ reserve(TYPENAME PointerToArray<Element>::size_type n) {
  */
 template<class Element>
 INLINE void PointerToArray<Element>::
-resize(TYPENAME PointerToArray<Element>::size_type n) {
+resize(typename PointerToArray<Element>::size_type n) {
   if ((this->_void_ptr) == nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
   }
@@ -207,7 +207,7 @@ resize(TYPENAME PointerToArray<Element>::size_type n) {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
 capacity() const {
   nassertr((this->_void_ptr) != nullptr, 0);
   return ((To *)(this->_void_ptr))->capacity();
@@ -217,7 +217,7 @@ capacity() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
 front() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -232,7 +232,7 @@ front() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
 back() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -247,7 +247,7 @@ back() const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
 insert(iterator position, const Element &x) {
   if ((this->_void_ptr) == nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -302,7 +302,7 @@ erase(iterator first, iterator last) {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
 operator [](size_type n) const {
   nassertd((this->_void_ptr) != nullptr) {
     ((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -318,7 +318,7 @@ operator [](size_type n) const {
  *
  */
 template<class Element>
-INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
 operator [](int n) const {
   return operator[]((size_type)n);
 }
@@ -728,7 +728,7 @@ ConstPointerToArray(pvector<Element> &&from, TypeHandle type_handle) :
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
 begin() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.begin();
@@ -740,7 +740,7 @@ begin() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
 end() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.begin();
@@ -752,7 +752,7 @@ end() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
 rbegin() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.rbegin();
@@ -764,7 +764,7 @@ rbegin() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
 rend() const {
   if ((this->_void_ptr) == nullptr) {
     return _empty_array.rbegin();
@@ -776,7 +776,7 @@ rend() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 size() const {
   return ((this->_void_ptr) == nullptr) ? 0 : ((To *)(this->_void_ptr))->size();
 }
@@ -785,7 +785,7 @@ size() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 max_size() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -806,7 +806,7 @@ empty() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 capacity() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -818,7 +818,7 @@ capacity() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 front() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -833,7 +833,7 @@ front() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 back() const {
   nassertd((this->_void_ptr) != nullptr) {
     ((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -849,7 +849,7 @@ back() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 operator [](size_type n) const {
   nassertd((this->_void_ptr) != nullptr) {
     ((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@@ -865,7 +865,7 @@ operator [](size_type n) const {
  *
  */
 template<class Element>
-INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 operator [](int n) const {
   return operator[]((size_type)n);
 }

panda/src/express/pointerToArray.h

@@ -91,7 +91,7 @@ public:
   // subset of this class.  So we define just the exportable interface here.
 #ifdef CPPPARSER
 PUBLISHED:
-  typedef TYPENAME pvector<Element>::size_type size_type;
+  typedef typename pvector<Element>::size_type size_type;
   INLINE PointerToArray(TypeHandle type_handle = get_type_handle(Element));
   INLINE static PointerToArray<Element> empty_array(size_type n, TypeHandle type_handle = get_type_handle(Element));
   INLINE PointerToArray(const PointerToArray<Element> &copy);
@@ -123,16 +123,16 @@ PUBLISHED:
 
 #else  // CPPPARSER
   // This is the actual, complete interface.
-  typedef TYPENAME PointerToArrayBase<Element>::To To;
-  typedef TYPENAME pvector<Element>::value_type value_type;
-  typedef TYPENAME pvector<Element>::reference reference;
-  typedef TYPENAME pvector<Element>::const_reference const_reference;
-  typedef TYPENAME pvector<Element>::iterator iterator;
-  typedef TYPENAME pvector<Element>::const_iterator const_iterator;
-  typedef TYPENAME pvector<Element>::reverse_iterator reverse_iterator;
-  typedef TYPENAME pvector<Element>::const_reverse_iterator const_reverse_iterator;
-  typedef TYPENAME pvector<Element>::difference_type difference_type;
-  typedef TYPENAME pvector<Element>::size_type size_type;
+  typedef typename PointerToArrayBase<Element>::To To;
+  typedef typename pvector<Element>::value_type value_type;
+  typedef typename pvector<Element>::reference reference;
+  typedef typename pvector<Element>::const_reference const_reference;
+  typedef typename pvector<Element>::iterator iterator;
+  typedef typename pvector<Element>::const_iterator const_iterator;
+  typedef typename pvector<Element>::reverse_iterator reverse_iterator;
+  typedef typename pvector<Element>::const_reverse_iterator const_reverse_iterator;
+  typedef typename pvector<Element>::difference_type difference_type;
+  typedef typename pvector<Element>::size_type size_type;
 
 public:
   INLINE PointerToArray(TypeHandle type_handle = get_type_handle(Element));
@@ -150,8 +150,8 @@ public:
 
   INLINE iterator begin() const;
   INLINE iterator end() const;
-  INLINE TYPENAME PointerToArray<Element>::reverse_iterator rbegin() const;
-  INLINE TYPENAME PointerToArray<Element>::reverse_iterator rend() const;
+  INLINE typename PointerToArray<Element>::reverse_iterator rbegin() const;
+  INLINE typename PointerToArray<Element>::reverse_iterator rend() const;
 
   // Equality and comparison operators are pointerwise for PointerToArrays,
   // not elementwise as in vector.
@@ -261,7 +261,7 @@ PUBLISHED:
 
   INLINE void clear();
 
-  typedef TYPENAME pvector<Element>::size_type size_type;
+  typedef typename pvector<Element>::size_type size_type;
   INLINE size_type size() const;
   INLINE const Element &get_element(size_type n) const;
   EXTENSION(const Element &__getitem__(size_type n) const);
@@ -279,21 +279,21 @@ PUBLISHED:
 
 #else  // CPPPARSER
   // This is the actual, complete interface.
-  typedef TYPENAME PointerToArrayBase<Element>::To To;
-  typedef TYPENAME pvector<Element>::value_type value_type;
-  typedef TYPENAME pvector<Element>::const_reference reference;
-  typedef TYPENAME pvector<Element>::const_reference const_reference;
-  typedef TYPENAME pvector<Element>::const_iterator iterator;
-  typedef TYPENAME pvector<Element>::const_iterator const_iterator;
+  typedef typename PointerToArrayBase<Element>::To To;
+  typedef typename pvector<Element>::value_type value_type;
+  typedef typename pvector<Element>::const_reference reference;
+  typedef typename pvector<Element>::const_reference const_reference;
+  typedef typename pvector<Element>::const_iterator iterator;
+  typedef typename pvector<Element>::const_iterator const_iterator;
 #if defined(WIN32_VC) || defined(WIN64_VC)
   // VC++ seems to break the const_reverse_iterator definition somehow.
-  typedef TYPENAME pvector<Element>::reverse_iterator reverse_iterator;
+  typedef typename pvector<Element>::reverse_iterator reverse_iterator;
 #else
-  typedef TYPENAME pvector<Element>::const_reverse_iterator reverse_iterator;
+  typedef typename pvector<Element>::const_reverse_iterator reverse_iterator;
 #endif
-  typedef TYPENAME pvector<Element>::const_reverse_iterator const_reverse_iterator;
-  typedef TYPENAME pvector<Element>::difference_type difference_type;
-  typedef TYPENAME pvector<Element>::size_type size_type;
+  typedef typename pvector<Element>::const_reverse_iterator const_reverse_iterator;
+  typedef typename pvector<Element>::difference_type difference_type;
+  typedef typename pvector<Element>::size_type size_type;
 
   INLINE ConstPointerToArray(const Element *begin, const Element *end, TypeHandle type_handle = get_type_handle(Element));
   INLINE ConstPointerToArray(const PointerToArray<Element> &copy);
@@ -306,8 +306,8 @@ PUBLISHED:
 
   INLINE iterator begin() const;
   INLINE iterator end() const;
-  INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator rbegin() const;
-  INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator rend() const;
+  INLINE typename ConstPointerToArray<Element>::reverse_iterator rbegin() const;
+  INLINE typename ConstPointerToArray<Element>::reverse_iterator rend() const;
 
   // Equality and comparison operators are pointerwise for PointerToArrays,
   // not elementwise as in vector.

panda/src/express/pointerToArrayBase.I

@@ -24,7 +24,7 @@ ReferenceCountedVector(TypeHandle type_handle) : pvector<Element>(type_handle) {
  */
 template<class Element>
 INLINE ReferenceCountedVector<Element>::
-ReferenceCountedVector(TYPENAME ReferenceCountedVector<Element>::size_type initial_size, TypeHandle type_handle) :
+ReferenceCountedVector(typename ReferenceCountedVector<Element>::size_type initial_size, TypeHandle type_handle) :
   pvector<Element>(initial_size, type_handle)
 {
 }
@@ -53,7 +53,7 @@ ReferenceCountedVector(pvector<Element> &&from) :
  *
  */
 template<class Element>
-INLINE TYPENAME ReferenceCountedVector<Element>::size_type ReferenceCountedVector<Element>::
+INLINE typename ReferenceCountedVector<Element>::size_type ReferenceCountedVector<Element>::
 size() const {
   return pvector<Element>::size();
 }
@@ -62,7 +62,7 @@ size() const {
  *
  */
 template<class Element>
-INLINE TYPENAME ReferenceCountedVector<Element>::iterator ReferenceCountedVector<Element>::
+INLINE typename ReferenceCountedVector<Element>::iterator ReferenceCountedVector<Element>::
 insert(iterator position, const Element &x) {
   return pvector<Element>::insert(position, x);
 }

panda/src/express/pointerToArrayBase.h

@@ -37,8 +37,8 @@
 template <class Element>
 class ReferenceCountedVector : public NodeReferenceCount, public pvector<Element> {
 public:
-  typedef TYPENAME pvector<Element>::iterator iterator;
-  typedef TYPENAME pvector<Element>::size_type size_type;
+  typedef typename pvector<Element>::iterator iterator;
+  typedef typename pvector<Element>::size_type size_type;
 
   INLINE ReferenceCountedVector(TypeHandle type_handle);
   INLINE ReferenceCountedVector(size_type initial_size, TypeHandle type_handle);
@@ -68,7 +68,7 @@ public:
 template <class Element>
 class PointerToArrayBase : public PointerToBase<ReferenceCountedVector<Element> > {
 public:
-  typedef TYPENAME PointerToBase<ReferenceCountedVector<Element> >::To To;
+  typedef typename PointerToBase<ReferenceCountedVector<Element> >::To To;
 
 protected:
   INLINE PointerToArrayBase(ReferenceCountedVector<Element> *ptr);

panda/src/express/threadSafePointerTo.I

@@ -41,7 +41,7 @@ INLINE ThreadSafePointerTo<T>::
  *
  */
 template<class T>
-INLINE TYPENAME ThreadSafePointerTo<T>::To &ThreadSafePointerTo<T>::
+INLINE typename ThreadSafePointerTo<T>::To &ThreadSafePointerTo<T>::
 operator *() const {
   return *((To *)AtomicAdjust::get_ptr(this->_void_ptr));
 }
@@ -50,7 +50,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE TYPENAME ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
+INLINE typename ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
 operator -> () const {
   return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
 }
@@ -72,7 +72,7 @@ operator T * () const {
  * work around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE TYPENAME ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
+INLINE typename ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
 p() const {
   return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
 }
@@ -102,8 +102,8 @@ operator = (const ThreadSafePointerTo<T> &copy) {
  */
 template<class T>
 INLINE ThreadSafeConstPointerTo<T>::
-ThreadSafeConstPointerTo(const TYPENAME ThreadSafeConstPointerTo<T>::To *ptr) :
-  ThreadSafePointerToBase<T>((TYPENAME ThreadSafeConstPointerTo<T>::To *)ptr)
+ThreadSafeConstPointerTo(const typename ThreadSafeConstPointerTo<T>::To *ptr) :
+  ThreadSafePointerToBase<T>((typename ThreadSafeConstPointerTo<T>::To *)ptr)
 {
 }
 
@@ -139,7 +139,7 @@ ThreadSafeConstPointerTo(const ThreadSafeConstPointerTo<T> &copy) :
  *
  */
 template<class T>
-INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To &ThreadSafeConstPointerTo<T>::
+INLINE const typename ThreadSafeConstPointerTo<T>::To &ThreadSafeConstPointerTo<T>::
 operator *() const {
   return *((To *)AtomicAdjust::get_ptr(this->_void_ptr));
 }
@@ -148,7 +148,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
+INLINE const typename ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
 operator -> () const {
   return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
 }
@@ -171,7 +171,7 @@ operator const T * () const {
  * to work around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
+INLINE const typename ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
 p() const {
   return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
 }

panda/src/express/threadSafePointerTo.h

@@ -26,7 +26,7 @@
 template <class T>
 class ThreadSafePointerTo : public ThreadSafePointerToBase<T> {
 public:
-  typedef TYPENAME ThreadSafePointerToBase<T>::To To;
+  typedef typename ThreadSafePointerToBase<T>::To To;
 PUBLISHED:
   INLINE ThreadSafePointerTo(To *ptr = nullptr);
   INLINE ThreadSafePointerTo(const ThreadSafePointerTo<T> &copy);
@@ -71,7 +71,7 @@ PUBLISHED:
 template <class T>
 class ThreadSafeConstPointerTo : public ThreadSafePointerToBase<T> {
 public:
-  typedef TYPENAME ThreadSafePointerToBase<T>::To To;
+  typedef typename ThreadSafePointerToBase<T>::To To;
 PUBLISHED:
   INLINE ThreadSafeConstPointerTo(const To *ptr = nullptr);
   INLINE ThreadSafeConstPointerTo(const ThreadSafePointerTo<T> &copy);

panda/src/express/weakPointerTo.I

@@ -43,7 +43,7 @@ WeakPointerTo(const WeakPointerTo<T> &copy) :
  *
  */
 template<class T>
-INLINE TYPENAME WeakPointerTo<T>::To &WeakPointerTo<T>::
+INLINE typename WeakPointerTo<T>::To &WeakPointerTo<T>::
 operator *() const {
   assert(!this->was_deleted());
   return *((To *)WeakPointerToBase<T>::_void_ptr);
@@ -53,7 +53,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
+INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
 operator -> () const {
   assert(!this->was_deleted());
   return (To *)WeakPointerToBase<T>::_void_ptr;
@@ -106,7 +106,7 @@ lock() const {
  * around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
+INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
 p() const {
   assert(!this->was_deleted());
   return (To *)WeakPointerToBase<T>::_void_ptr;
@@ -117,7 +117,7 @@ p() const {
  * deleted.
  */
 template<class T>
-INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
+INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
 get_orig() const {
   return (To *)WeakPointerToBase<T>::_void_ptr;
 }
@@ -158,7 +158,7 @@ operator = (const WeakPointerTo<T> &copy) {
 template<class T>
 INLINE WeakConstPointerTo<T>::
 WeakConstPointerTo(const To *ptr) :
-  WeakPointerToBase<T>((TYPENAME WeakConstPointerTo<T>::To *)ptr)
+  WeakPointerToBase<T>((typename WeakConstPointerTo<T>::To *)ptr)
 {
 }
 
@@ -206,7 +206,7 @@ WeakConstPointerTo(const WeakConstPointerTo<T> &copy) :
  *
  */
 template<class T>
-INLINE const TYPENAME WeakConstPointerTo<T>::To &WeakConstPointerTo<T>::
+INLINE const typename WeakConstPointerTo<T>::To &WeakConstPointerTo<T>::
 operator *() const {
   assert(!this->was_deleted());
   return *((To *)WeakPointerToBase<T>::_void_ptr);
@@ -216,7 +216,7 @@ operator *() const {
  *
  */
 template<class T>
-INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
+INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
 operator -> () const {
   assert(!this->was_deleted());
   return (To *)WeakPointerToBase<T>::_void_ptr;
@@ -267,7 +267,7 @@ lock() const {
  * work around compiler problems, particularly for implicit upcasts.
  */
 template<class T>
-INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
+INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
 p() const {
   assert(!this->was_deleted());
   return (To *)WeakPointerToBase<T>::_void_ptr;
@@ -278,7 +278,7 @@ p() const {
  * deleted.
  */
 template<class T>
-INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
+INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
 get_orig() const {
   return (To *)WeakPointerToBase<T>::_void_ptr;
 }

panda/src/express/weakPointerTo.h

@@ -28,7 +28,7 @@
 template <class T>
 class WeakPointerTo : public WeakPointerToBase<T> {
 public:
-  typedef TYPENAME WeakPointerToBase<T>::To To;
+  typedef typename WeakPointerToBase<T>::To To;
 PUBLISHED:
   INLINE WeakPointerTo(To *ptr = nullptr);
   INLINE WeakPointerTo(const PointerTo<T> &copy);
@@ -64,7 +64,7 @@ PUBLISHED:
 template <class T>
 class WeakConstPointerTo : public WeakPointerToBase<T> {
 public:
-  typedef TYPENAME WeakPointerToBase<T>::To To;
+  typedef typename WeakPointerToBase<T>::To To;
 PUBLISHED:
   INLINE WeakConstPointerTo(const To *ptr = nullptr);
   INLINE WeakConstPointerTo(const PointerTo<T> &copy);

panda/src/putil/bitMask.I

@@ -168,7 +168,7 @@ is_all_on() const {
  * BitMask, shifted to the least-significant position.
  */
 template<class WType, int nbits>
-INLINE TYPENAME BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
+INLINE typename BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
 extract(int low_bit, int size) const {
   return (_word >> low_bit) &
     BitMask<WType, nbits>::lower_on(size)._word;
@@ -242,7 +242,7 @@ set_range_to(bool value, int low_bit, int size) {
  * Returns the entire BitMask as a single word.
  */
 template<class WType, int nbits>
-INLINE TYPENAME BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
+INLINE typename BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
 get_word() const {
   return _word;
 }

panda/src/putil/copyOnWritePointer.I

@@ -357,11 +357,11 @@ operator = (PointerTo<T> &&from) noexcept {
  * See CopyOnWritePointer::get_read_pointer().
  */
 template<class T>
-INLINE CPT(TYPENAME CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
+INLINE CPT(typename CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
 get_read_pointer(Thread *current_thread) const {
   // This is necessary because we don't currently have a way to cast between
   // two compatible PointerTo types without losing the reference count.
-  CPT(TYPENAME CopyOnWritePointerTo<T>::To) to;
+  CPT(typename CopyOnWritePointerTo<T>::To) to;
   CPT(CopyOnWriteObject) from = CopyOnWritePointer::get_read_pointer(current_thread);
   to.cheat() = (const To *)from.p();
   from.cheat() = nullptr;
@@ -372,7 +372,7 @@ get_read_pointer(Thread *current_thread) const {
  * See CopyOnWritePointer::get_read_pointer().
  */
 template<class T>
-INLINE const TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
+INLINE const typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
 get_read_pointer(Thread *current_thread) const {
   return (const To *)CopyOnWritePointer::get_read_pointer(current_thread);
 }
@@ -385,11 +385,11 @@ get_read_pointer(Thread *current_thread) const {
  * See CopyOnWritePointer::get_write_pointer().
  */
 template<class T>
-INLINE PT(TYPENAME CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
+INLINE PT(typename CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
 get_write_pointer() {
   // This is necessary because we don't currently have a way to cast between
   // two compatible PointerTo types without losing the reference count.
-  PT(TYPENAME CopyOnWritePointerTo<T>::To) to;
+  PT(typename CopyOnWritePointerTo<T>::To) to;
   PT(CopyOnWriteObject) from = CopyOnWritePointer::get_write_pointer();
   to.cheat() = (To *)from.p();
   from.cheat() = nullptr;
@@ -400,7 +400,7 @@ get_write_pointer() {
  * See CopyOnWritePointer::get_write_pointer().
  */
 template<class T>
-INLINE TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
+INLINE typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
 get_write_pointer() {
   return (To *)CopyOnWritePointer::get_write_pointer();
 }
@@ -412,7 +412,7 @@ get_write_pointer() {
  * See CopyOnWritePointer::get_unsafe_pointer().
  */
 template<class T>
-INLINE TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
+INLINE typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
 get_unsafe_pointer() {
   return (To *)(CopyOnWritePointer::get_unsafe_pointer());
 }

panda/src/putil/doubleBitMask.I

@@ -167,7 +167,7 @@ is_all_on() const {
  * DoubleBitMask, shifted to the least-significant position.
  */
 template<class BMType>
-INLINE TYPENAME DoubleBitMask<BMType>::WordType DoubleBitMask<BMType>::
+INLINE typename DoubleBitMask<BMType>::WordType DoubleBitMask<BMType>::
 extract(int low_bit, int size) const {
   if (low_bit >= half_bits) {
     return _hi.extract(low_bit - half_bits, size);

panda/src/putil/doubleBitMask.h

@@ -27,7 +27,7 @@
 template<class BMType>
 class DoubleBitMask {
 public:
-  typedef TYPENAME BMType::WordType WordType;
+  typedef typename BMType::WordType WordType;
 
 PUBLISHED:
   typedef BMType BitMaskType;

panda/src/putil/iterator_types.h

@@ -24,7 +24,7 @@
 template<class pair_iterator>
 class first_of_pair_iterator : public pair_iterator {
 public:
-  typedef TYPENAME pair_iterator::value_type::first_type value_type;
+  typedef typename pair_iterator::value_type::first_type value_type;
 
   first_of_pair_iterator() = default;
   first_of_pair_iterator(const pair_iterator &init) : pair_iterator(init) { }
@@ -42,7 +42,7 @@ public:
 template<class pair_iterator>
 class second_of_pair_iterator : public pair_iterator {
 public:
-  typedef TYPENAME pair_iterator::value_type::second_type value_type;
+  typedef typename pair_iterator::value_type::second_type value_type;
 
   second_of_pair_iterator() = default;
   second_of_pair_iterator(const pair_iterator &init) : pair_iterator(init) { }