typename->TYPENAME

dtool/src/dtoolbase/dallocator.T

@@ -63,9 +63,9 @@ dallocator() throw() {
 }
 
 template<class Type>
-INLINE typename dallocator<Type>::pointer dallocator<Type>::
-allocate(typename dallocator<Type>::size_type n, allocator<void>::const_pointer) {
-  return (typename dallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
+INLINE TYPENAME dallocator<Type>::pointer dallocator<Type>::
+allocate(TYPENAME dallocator<Type>::size_type n, allocator<void>::const_pointer) {
+  return (TYPENAME dallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
 }
 
 template<class Type>

dtool/src/dtoolbase/pallocator.T

@@ -78,9 +78,9 @@ pallocator() throw() {
 }
 
 template<class Type>
-INLINE typename pallocator<Type>::pointer pallocator<Type>::
-allocate(typename pallocator<Type>::size_type n, typename allocator<void>::const_pointer) {
-  return (typename pallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
+INLINE TYPENAME pallocator<Type>::pointer pallocator<Type>::
+allocate(TYPENAME pallocator<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
+  return (TYPENAME pallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
 }
 
 template<class Type>

panda/src/express/ordered_vector.I

@@ -72,7 +72,7 @@ INLINE ordered_vector<Key, Compare>::
 //               the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
 begin() {
   return _vector.begin();
 }
@@ -84,7 +84,7 @@ begin() {
 //               ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
 end() {
   return _vector.end();
 }
@@ -96,7 +96,7 @@ end() {
 //               the ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rbegin() {
   return _vector.rbegin();
 }
@@ -108,7 +108,7 @@ rbegin() {
 //               ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rend() {
   return _vector.rend();
 }
@@ -120,7 +120,7 @@ rend() {
 //               the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
 begin() const {
   return _vector.begin();
 }
@@ -132,7 +132,7 @@ begin() const {
 //               ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
 end() const {
   return _vector.end();
 }
@@ -144,7 +144,7 @@ end() const {
 //               the ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rbegin() const {
   return _vector.rbegin();
 }
@@ -156,7 +156,7 @@ rbegin() const {
 //               ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rend() const {
   return _vector.rend();
 }
@@ -167,8 +167,8 @@ rend() const {
 //  Description: Returns the nth element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
-operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
+INLINE TYPENAME ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
+operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
   return _vector[n];
 }
 
@@ -178,8 +178,8 @@ operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
 //  Description: Returns the nth element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
-operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) const {
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
+operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) const {
   return _vector[n];
 }
 
@@ -189,7 +189,7 @@ operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) const {
 //  Description: Returns the number of elements in the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 size() const {
   return _vector.size();
 }
@@ -201,7 +201,7 @@ size() const {
 //               possibly be stored in an ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 max_size() const {
   return _vector.max_size();
 }
@@ -309,8 +309,8 @@ operator >= (const ordered_vector<Key, Compare> &other) const {
 //               the insert operation has taken place.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename pair<typename ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
-insert_unique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+INLINE TYPENAME pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
+insert_unique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   ITERATOR position = find_insert_position(begin(), end(), key);
 #ifdef NDEBUG
   pair<ITERATOR, bool> bogus_result(end(), false);
@@ -341,8 +341,8 @@ insert_unique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
 //               element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-insert_nonunique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_nonunique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   ITERATOR position = find_insert_position(begin(), end(), key);
   nassertr(position >= begin() && position <= end(), end());
 
@@ -358,8 +358,8 @@ insert_nonunique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
 //               and returns the next sequential iterator.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-erase(typename ordered_vector<Key, Compare>::ITERATOR position) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR position) {
   SIZE_TYPE count = position - begin();
   _vector.erase(position);
   return begin() + count;
@@ -372,8 +372,8 @@ erase(typename ordered_vector<Key, Compare>::ITERATOR position) {
 //               returns the number of elements removed.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
-erase(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+erase(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   pair<ITERATOR, ITERATOR> result = equal_range(key);
   SIZE_TYPE count = result.second - result.first;
   erase(result.first, result.second);
@@ -388,8 +388,8 @@ erase(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
 INLINE void ordered_vector<Key, Compare>::
-erase(typename ordered_vector<Key, Compare>::ITERATOR first,
-      typename ordered_vector<Key, Compare>::ITERATOR last) {
+erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
+      TYPENAME ordered_vector<Key, Compare>::ITERATOR last) {
   _vector.erase(first, last);
 }
 
@@ -413,8 +413,8 @@ clear() {
 //               key, the particular iterator returned is not defined.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_find(begin(), end(), end(), key));
 }
 
@@ -427,8 +427,8 @@ find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 //               key, the particular iterator returned is not defined.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_find(begin(), end(), end(), key);
 }
 
@@ -449,8 +449,8 @@ find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
 //               !Compare(b, a), but not necessarily the converse.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_find_particular(begin(), end(), end(), key));
 }
 
@@ -468,8 +468,8 @@ find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 //               particular iterator returned is not defined./
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_find_particular(begin(), end(), end(), key);
 }
 
@@ -480,7 +480,7 @@ find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) cons
 //               to the key that are in the vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 count(const key_type &key) const {
   return r_count(begin(), end(), key);
 }
@@ -492,8 +492,8 @@ count(const key_type &key) const {
 //               than key, or end() if all elements are less than key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_lower_bound(begin(), end(), key));
 }
 
@@ -504,8 +504,8 @@ lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 //               than key, or end() if all elements are less than key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_lower_bound(begin(), end(), key);
 }
 
@@ -517,8 +517,8 @@ lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
 //               key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_upper_bound(begin(), end(), key));
 }
 
@@ -530,8 +530,8 @@ upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 //               key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_upper_bound(begin(), end(), key);
 }
 
@@ -541,11 +541,11 @@ upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
 //  Description: Returns the pair (lower_bound(key), upper_bound(key)).
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<typename ordered_vector<Key, Compare>::ITERATOR, typename ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
-equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
-  pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> result;
+INLINE pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
+equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
+  pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> result;
   result = r_equal_range(begin(), end(), key);
-  return pair<typename ordered_vector<Key, Compare>::ITERATOR, typename ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
+  return pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -554,8 +554,8 @@ equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
 //  Description: Returns the pair (lower_bound(key), upper_bound(key)).
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
-equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+INLINE pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
+equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_equal_range(begin(), end(), key);
 }
 
@@ -580,7 +580,7 @@ swap(ordered_vector<Key, Compare> &copy) {
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
 INLINE void ordered_vector<Key, Compare>::
-reserve(typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
+reserve(TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
   _vector.reserve(n);
 }
 
@@ -642,8 +642,8 @@ push_back(const value_type &key) {
 //               some of these methods.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-nci(typename ordered_vector<Key, Compare>::CONST_ITERATOR i) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+nci(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR i) {
   return begin() + (i - begin());
 }
 
@@ -655,10 +655,10 @@ nci(typename ordered_vector<Key, Compare>::CONST_ITERATOR i) {
 //               corresponding iterator.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
-                     typename ordered_vector<Key, Compare>::ITERATOR last,
-                     const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find_insert_position(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
+                     TYPENAME ordered_vector<Key, Compare>::ITERATOR last,
+                     const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   ITERATOR result = r_find_insert_position(first, last, key);
   return result;
 }
@@ -705,9 +705,9 @@ operator = (const ov_set<Key, Compare> &copy) {
 //  Description: Maps to insert_unique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ov_set<Key, Compare>::ITERATOR ov_set<Key, Compare>::
-insert(typename ov_set<Key, Compare>::ITERATOR position, 
-       const typename ov_set<Key, Compare>::VALUE_TYPE &key) {
+TYPENAME ov_set<Key, Compare>::ITERATOR ov_set<Key, Compare>::
+insert(TYPENAME ov_set<Key, Compare>::ITERATOR position, 
+       const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_unique(position, key);
 }
 
@@ -717,8 +717,8 @@ insert(typename ov_set<Key, Compare>::ITERATOR position,
 //  Description: Maps to insert_unique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<typename ov_set<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
-insert(const typename ov_set<Key, Compare>::VALUE_TYPE &key) {
+INLINE pair<TYPENAME ov_set<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
+insert(const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_unique(key);
 }
 
@@ -786,9 +786,9 @@ operator = (const ov_multiset<Key, Compare> &copy) {
 //  Description: Maps to insert_nonunique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
-insert(typename ov_multiset<Key, Compare>::ITERATOR position, 
-       const typename ov_multiset<Key, Compare>::VALUE_TYPE &key) {
+TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
+insert(TYPENAME ov_multiset<Key, Compare>::ITERATOR position, 
+       const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_nonunique(position, key);
 }
 
@@ -798,8 +798,8 @@ insert(typename ov_multiset<Key, Compare>::ITERATOR position,
 //  Description: Maps to insert_nonunique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE typename ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
-insert(const typename ov_multiset<Key, Compare>::VALUE_TYPE &key) {
+INLINE TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
+insert(const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_nonunique(key);
 }
 

panda/src/express/ordered_vector.T

@@ -32,9 +32,9 @@
 //               referencing the original value is returned.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-insert_unique(typename ordered_vector<Key, Compare>::ITERATOR position, 
-              const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_unique(TYPENAME ordered_vector<Key, Compare>::ITERATOR position, 
+              const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   if (position != end()) {
     // If we're not inserting at the end, the element we're
     // inserting before should not lexicographically precede this one.
@@ -78,9 +78,9 @@ insert_unique(typename ordered_vector<Key, Compare>::ITERATOR position,
 //               same key to be inserted.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-insert_nonunique(typename ordered_vector<Key, Compare>::ITERATOR position, 
-                 const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_nonunique(TYPENAME ordered_vector<Key, Compare>::ITERATOR position, 
+                 const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   if (position != end()) {
     // If we're not inserting at the end, the element we're
     // inserting before should not lexicographically precede this one.
@@ -162,10 +162,10 @@ verify_list_nonunique() const {
 //               find_insert_position().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
-r_find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
-                       typename ordered_vector<Key, Compare>::ITERATOR last,
-                       const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
+TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+r_find_insert_position(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
+                       TYPENAME ordered_vector<Key, Compare>::ITERATOR last,
+                       const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
   if (first == last) {
     // The list is empty; the insert position is the last of the list.
     return last;
@@ -190,11 +190,11 @@ r_find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
 //  Description: The recursive implementation of find().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-r_find(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-       typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-       typename ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
-       const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_find(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+       TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+       TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
+       const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
@@ -223,11 +223,11 @@ r_find(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
 //  Description: The recursive implementation of find_particular().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-r_find_particular(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-                  typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-                  typename ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
-                  const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_find_particular(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+                  TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+                  TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
+                  const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
@@ -276,11 +276,11 @@ r_find_particular(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
 //  Description: The recursive implementation of count().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
-r_count(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-        typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-        const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
-  typedef pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
+TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+r_count(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+        TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+        const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+  typedef pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
 
   if (first == last) {
     // The list is empty; the key is not on the list.
@@ -312,10 +312,10 @@ r_count(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
 //  Description: The recursive implementation of lower_bound().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-r_lower_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-              typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-              const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_lower_bound(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
@@ -345,10 +345,10 @@ r_lower_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
 //  Description: The recursive implementation of upper_bound().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
-r_upper_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-              typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-              const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_upper_bound(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
@@ -378,11 +378,11 @@ r_upper_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
 //  Description: The recursive implementation of equal_range().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
-r_equal_range(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
-              typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
-              const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
-  typedef pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
+pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
+r_equal_range(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+  typedef pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::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
@@ -255,8 +255,8 @@ private:
 template<class Key, class Compare = less<Key> >
 class ov_set : public ordered_vector<Key, Compare> {
 public:
-  typedef typename ordered_vector<Key, Compare>::ITERATOR ITERATOR;
-  typedef typename ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
+  typedef TYPENAME ordered_vector<Key, Compare>::ITERATOR ITERATOR;
+  typedef TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
 
   INLINE ov_set(const Compare &compare = Compare());
   INLINE ov_set(const ov_set<Key, Compare> &copy);
@@ -278,8 +278,8 @@ public:
 template<class Key, class Compare = less<Key> >
 class ov_multiset : public ordered_vector<Key, Compare> {
 public:
-  typedef typename ordered_vector<Key, Compare>::ITERATOR ITERATOR;
-  typedef typename ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
+  typedef TYPENAME ordered_vector<Key, Compare>::ITERATOR ITERATOR;
+  typedef TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
 
   INLINE ov_multiset(const Compare &compare = Compare());
   INLINE ov_multiset(const ov_multiset<Key, Compare> &copy);

panda/src/express/pointerTo.I

@@ -315,7 +315,7 @@ PointerTo(const PointerTo<T> &copy) :
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE typename PointerTo<T>::To &PointerTo<T>::
+INLINE TYPENAME PointerTo<T>::To &PointerTo<T>::
 operator *() const {
   return *_ptr;
 }
@@ -326,7 +326,7 @@ operator *() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE typename PointerTo<T>::To *PointerTo<T>::
+INLINE TYPENAME PointerTo<T>::To *PointerTo<T>::
 operator -> () const {
   return _ptr;
 }
@@ -343,7 +343,7 @@ operator -> () const {
 ////////////////////////////////////////////////////////////////////
 template<class T>
 INLINE PointerTo<T>::
-operator typename PointerToBase<T>::To *() const {
+operator TYPENAME PointerToBase<T>::To *() const {
   return _ptr;
 }
 
@@ -355,7 +355,7 @@ operator typename PointerToBase<T>::To *() const {
 //               for implicit upcasts.
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE typename PointerTo<T>::To *PointerTo<T>::
+INLINE TYPENAME PointerTo<T>::To *PointerTo<T>::
 p() const {
   return _ptr;
 }
@@ -366,7 +366,7 @@ p() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE typename PointerTo<T> &PointerTo<T>::
+INLINE TYPENAME PointerTo<T> &PointerTo<T>::
 operator = (To *ptr) {
   reassign(ptr);
   return *this;
@@ -378,7 +378,7 @@ operator = (To *ptr) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE typename PointerTo<T> &PointerTo<T>::
+INLINE TYPENAME PointerTo<T> &PointerTo<T>::
 operator = (const PointerTo<T> &copy) {
   reassign((const PointerToBase<T> &)copy);
   return *this;
@@ -426,7 +426,7 @@ ConstPointerTo(const ConstPointerTo<T> &copy) :
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE const typename ConstPointerTo<T>::To &ConstPointerTo<T>::
+INLINE const TYPENAME ConstPointerTo<T>::To &ConstPointerTo<T>::
 operator *() const {
   return *_ptr;
 }
@@ -437,7 +437,7 @@ operator *() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
+INLINE const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
 operator -> () const {
   return _ptr;
 }
@@ -455,8 +455,8 @@ operator -> () const {
 
 #ifndef CPPPARSER
 template<class T>
-INLINE typename ConstPointerTo<T>::
-operator const typename PointerToBase<T>::To *() const {
+INLINE TYPENAME ConstPointerTo<T>::
+operator const TYPENAME PointerToBase<T>::To *() const {
   return _ptr;
 }
 #else
@@ -476,7 +476,7 @@ operator const PointerToBase<T>::To *() const {
 //               for implicit upcasts.
 ////////////////////////////////////////////////////////////////////
 template<class T>
-INLINE const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
+INLINE const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
 p() const {
   return _ptr;
 }

panda/src/express/pointerToArray.I

@@ -75,7 +75,7 @@ PointerToArray(const PointerToArray<Element> &copy) :
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
 begin() const {
   if (_ptr == NULL) {
     return _empty_array.begin();
@@ -89,7 +89,7 @@ begin() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
 end() const {
   if (_ptr == NULL) {
     return _empty_array.begin();
@@ -103,7 +103,7 @@ end() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
 rbegin() const {
   if (_ptr == NULL) {
     return _empty_array.rbegin();
@@ -117,7 +117,7 @@ rbegin() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
 rend() const {
   if (_ptr == NULL) {
     return _empty_array.rbegin();
@@ -131,7 +131,7 @@ rend() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
 size() const {
   return (_ptr == NULL) ? 0 : _ptr->size();
 }
@@ -142,7 +142,7 @@ size() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
 max_size() const {
   nassertd(_ptr != NULL) {
     ((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -168,7 +168,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 (_ptr == NULL) {
     reassign(new RefCountObj<pvector<Element> >);
   }
@@ -181,7 +181,7 @@ reserve(typename PointerToArray<Element>::size_type n) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
 capacity() const {
   nassertr(_ptr != NULL, 0);
   return _ptr->capacity();
@@ -193,7 +193,7 @@ capacity() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
 front() const {
   nassertd(_ptr != NULL) {
     ((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -210,7 +210,7 @@ front() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
 back() const {
   nassertd(_ptr != NULL) {
     ((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -227,7 +227,7 @@ back() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
+INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
 insert(iterator position, const Element &x) const {
   nassertr(_ptr != NULL, position);
   nassertr(position >= _ptr->begin() &&
@@ -506,7 +506,7 @@ ConstPointerToArray(const ConstPointerToArray<Element> &copy) :
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
 begin() const {
   if (_ptr == NULL) {
     return _empty_array.begin();
@@ -520,7 +520,7 @@ begin() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
 end() const {
   if (_ptr == NULL) {
     return _empty_array.begin();
@@ -534,7 +534,7 @@ end() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
 rbegin() const {
   if (_ptr == NULL) {
     return _empty_array.rbegin();
@@ -548,7 +548,7 @@ rbegin() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
 rend() const {
   if (_ptr == NULL) {
     return _empty_array.rbegin();
@@ -562,7 +562,7 @@ rend() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 size() const {
   return (_ptr == NULL) ? 0 : _ptr->size();
 }
@@ -573,7 +573,7 @@ size() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 max_size() const {
   nassertd(_ptr != NULL) {
     ((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -598,7 +598,7 @@ empty() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
 capacity() const {
   nassertd(_ptr != NULL) {
     ((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -613,7 +613,7 @@ capacity() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 operator[](size_type n) const {
   nassertd(_ptr != NULL) {
     ((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -632,7 +632,7 @@ operator[](size_type n) const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 front() const {
   nassertd(_ptr != NULL) {
     ((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
@@ -649,7 +649,7 @@ front() const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 template<class Element>
-INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
+INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
 back() const {
   nassertd(_ptr != NULL) {
     ((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);

panda/src/express/pointerToArray.h

@@ -91,15 +91,15 @@
 template <class Element>
 class PointerToArray : public PointerToBase<RefCountObj<pvector<Element> > > {
 public:
-  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 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;
 
 PUBLISHED:
   INLINE PointerToArray();
@@ -116,8 +116,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.
@@ -196,20 +196,20 @@ private:
 template <class Element>
 class ConstPointerToArray : public PointerToBase<RefCountObj<pvector<Element> > > {
 public:
-  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 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;
 #ifdef WIN32_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();
   INLINE ConstPointerToArray(const PointerToArray<Element> &copy);
@@ -219,8 +219,8 @@ public:
 
   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.