diff --git a/include/boost/typeof/compliant/integral_template_param.hpp b/include/boost/typeof/compliant/integral_template_param.hpp
index 41536c3..811fadb 100755
--- a/include/boost/typeof/compliant/integral_template_param.hpp
+++ b/include/boost/typeof/compliant/integral_template_param.hpp
@@ -1,4 +1,5 @@
 // Copyright (C) 2005 Arkadiy Vertleyb
+// Copyright (C) 2005 Peder Holt
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
@@ -9,17 +10,28 @@
 
 // INTEGRAL_PARAM "virtual functions" implementation
 
-#define BOOST_TYPEOF_ENCODE_INTEGRAL_PARAM(This, n)\
+#define BOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
     typedef typename encode_integral<\
         BOOST_PP_CAT(V, n),\
-        BOOST_TYPEOF_PARAM_GETTYPE(This),\
+        BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This),\
         BOOST_PP_CAT(P, n)\
     >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
 
-#define BOOST_TYPEOF_DECODE_INTEGRAL_PARAM(This, n)\
-    typedef decode_integral<BOOST_TYPEOF_PARAM_GETTYPE(This), BOOST_PP_CAT(iter, n)> BOOST_PP_CAT(d, n);\
-    static const BOOST_TYPEOF_PARAM_GETTYPE(This) BOOST_PP_CAT(P, n) = BOOST_PP_CAT(d, n)::value;\
+#define BOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
+    typedef decode_integral<BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This), BOOST_PP_CAT(iter, n)> BOOST_PP_CAT(d, n);\
+    static const BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This) BOOST_PP_CAT(P, n) = BOOST_PP_CAT(d, n)::value;\
     typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
 
+#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER(Param)\
+    (BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param))0
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_DECLARATION_TYPE(Param)\
+    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER_TYPES(Param, n)\
+    BOOST_PP_CAT(T,n)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_TT_CATEGORY 1
+
 
 #endif//BOOST_TYPEOF_COMPLIANT_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/boost/typeof/compliant/template_encoding.hpp b/include/boost/typeof/compliant/template_encoding.hpp
index 2a9e1ad..c064ed9 100755
--- a/include/boost/typeof/compliant/template_encoding.hpp
+++ b/include/boost/typeof/compliant/template_encoding.hpp
@@ -15,25 +15,29 @@
 #include <boost/typeof/compliant/integral_template_param.hpp>
 #include <boost/typeof/compliant/template_template_param.hpp>
 
-//////////
+#include <boost/preprocessor/seq/transform.hpp>
 
-// "function objects"
+#define BOOST_TYPEOF_PLACEHOLDER(z, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER, elem)(elem)
+
+#define BOOST_TYPEOF_PLACEHOLDER_TYPES(z, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER_TYPES, elem)(elem, n)
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
-    BOOST_TYPEOF_PARAM_ENCODE(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
+    BOOST_TYPEOF_VIRTUAL(ENCODE, elem)(elem, n)
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
-    BOOST_TYPEOF_PARAM_DECODE(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
+    BOOST_TYPEOF_VIRTUAL(DECODE, elem)(elem, n)
 
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z,n,elem) \
-    BOOST_TYPEOF_PARAM_EXPAND_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(P, n)
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z, n, elem) \
+    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(P, n)
 
 #define BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\
     Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) >
 
 //Since we are creating an internal decode struct, we need to use different template names, T instead of P.
 #define BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
-    BOOST_TYPEOF_PARAM_EXPAND_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(T, n)
+    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(T, n)
 
 //Default template param decoding
 #define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE(Name,Params)\
@@ -45,39 +49,39 @@
         BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE,\
         BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE)(Name,Params)
 
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, ID)\
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, Size, ID)\
     BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name, Params, ID)\
     template<class V\
-        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
+        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params, BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
     >\
-    struct encode_type_impl<V, Name<\
-        BOOST_PP_ENUM_PARAMS(\
-        BOOST_PP_SEQ_SIZE(Params),\
-        P)> >\
+    struct encode_type_impl<V, Name<BOOST_PP_ENUM_PARAMS(Size, P)> >\
     {\
         typedef typename BOOST_TYPEOF_PUSH_BACK<V, boost::mpl::size_t<ID> >::type V0;\
-        BOOST_PP_SEQ_FOR_EACH_I(\
-            BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM,\
-            ~,\
-            Params)\
-        typedef BOOST_PP_CAT(V, BOOST_PP_SEQ_SIZE(Params)) type;\
+        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM, ~, Params)\
+        typedef BOOST_PP_CAT(V, Size) type;\
     };\
     template<class Iter>\
     struct decode_type_impl<boost::mpl::size_t<ID>, Iter>\
     {\
         typedef Iter iter0;\
-        BOOST_PP_SEQ_FOR_EACH_I(\
-            BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM,\
-            ~,\
-            Params)\
-        BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name,Params)\
-        typedef BOOST_PP_CAT(iter, BOOST_PP_SEQ_SIZE(Params)) iter;\
+        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM, ~, Params)\
+        BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name, Params)\
+        typedef BOOST_PP_CAT(iter, Size) iter;\
     };
 
+#define BOOST_TYPEOF_OBJECT_MAKER(s, data, elem)\
+    BOOST_TYPEOF_MAKE_OBJ(elem)
+
+#define BOOST_TYPEOF_TRANSFORM_PARAMS(Params)\
+    BOOST_PP_SEQ_TRANSFORM(BOOST_TYPEOF_OBJECT_MAKER, ~, Params)
+
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_X(Name, Params)\
     namespace boost{namespace type_of{namespace{\
-    BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, BOOST_TYPEOF_UNIQUE_ID())\
+        BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(\
+            Name,\
+            BOOST_TYPEOF_TRANSFORM_PARAMS(Params),\
+            BOOST_PP_SEQ_SIZE(Params),\
+            BOOST_TYPEOF_UNIQUE_ID())\
     }}}
 
 #endif//BOOST_TYPEOF_COMPLIANT_TEMPLATE_ENCODING_HPP_INCLUDED
diff --git a/include/boost/typeof/compliant/template_template_param.hpp b/include/boost/typeof/compliant/template_template_param.hpp
index 318e0ee..e9f421b 100644
--- a/include/boost/typeof/compliant/template_template_param.hpp
+++ b/include/boost/typeof/compliant/template_template_param.hpp
@@ -1,4 +1,5 @@
 // Copyright (C) 2005 Peder Holt
+// Copyright (C) 2005 Arkadiy Vertleyb
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
@@ -9,6 +10,47 @@
 #include <boost/preprocessor/comparison/not_equal.hpp>
 #include <boost/preprocessor/arithmetic/dec.hpp>
 
+#define BOOST_TYPEOF_MAKE_OBJ_template(x)   BOOST_TYPEOF_TEMPLATE_PARAM(x)
+#define BOOST_TYPEOF_TEMPLATE(X) template(X) BOOST_TYPEOF_EAT
+#define BOOST_TYPEOF_template(X) (template(X))
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM(Params)\
+    (TEMPLATE_PARAM)\
+    (Params)
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)\
+    BOOST_PP_SEQ_ELEM(1, This)
+
+//Encode / decode this
+#define BOOST_TYPEOF_TEMPLATE_PARAM_ENCODE(This, n)\
+   typedef typename encode_template<BOOST_PP_CAT(V, n),\
+       BOOST_PP_CAT(P, n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_TRANSFORM_PARAMS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)),BOOST_TYPEOF_PLACEHOLDER)>\
+   >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_DECODE(This, n)\
+   typedef decode_template< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
+   typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
+   typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
+
+// template<class, unsigned int, ...> class
+#define BOOST_TYPEOF_TEMPLATE_PARAM_EXPANDTYPE(This) \
+    template <BOOST_PP_SEQ_ENUM(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This))> class
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER(Param)\
+    Nested_Template_Template_Arguments_Not_Supported
+
+//'template<class,int> class' is reduced to 'class'
+#define BOOST_TYPEOF_TEMPLATE_PARAM_DECLARATION_TYPE(Param) class
+
+// T3<int, (unsigned int)0, ...>
+#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER_TYPES(Param, n)\
+    BOOST_PP_CAT(T,n)<BOOST_TYPEOF_SEQ_ENUM_1(BOOST_TYPEOF_TRANSFORM_PARAMS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(Param)),BOOST_TYPEOF_PLACEHOLDER)>
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_TT_CATEGORY 2
+
+////////////////////////////
+// move to encode_decode?
+
 namespace boost
 {
     namespace type_of 
@@ -28,40 +70,8 @@ namespace boost
     }
 }
 
-#define BOOST_TYPEOF_MAKE_OBJ_template(x)   BOOST_TYPEOF_TEMPLATE_PARAM(x)
-#define BOOST_TYPEOF_TEMPLATE(X) template(X) BOOST_TYPEOF_EAT
-#define BOOST_TYPEOF_template(X) (template(X))
-
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM(Type)\
-    (TEMPLATE_PARAM)\
-    (Type)
-
-//Encode / decode this
-#define BOOST_TYPEOF_ENCODE_TEMPLATE_PARAM(This, n)\
-   typedef typename encode_template<BOOST_PP_CAT(V, n),\
-       BOOST_PP_CAT(P, n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_PARAM_GETTYPE(This),BOOST_TYPEOF_PLACEHOLDER)>\
-   >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
-
-#define BOOST_TYPEOF_DECODE_TEMPLATE_PARAM(This, n)\
-   typedef decode_template< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
-   typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
-   typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
-
-//Expand argument
-#define BOOST_TYPEOF_PARAM_EXPAND_TEMPLATE_PARAM(Param) \
-    template <BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_PARAM_GETTYPE(Param),BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_TYPE)> class
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_TYPE(z,n,elem)\
-    BOOST_TYPEOF_PARAM_EXPAND_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem))
-
-//Placeholder arguments to create a dummy template template.
-#define BOOST_TYPEOF_PLACEHOLDER(z,n,elem)\
-    BOOST_PP_CAT(BOOST_TYPEOF_PLACEHOLDER_, BOOST_PP_SEQ_ELEM(0, BOOST_TYPEOF_MAKE_OBJ(elem)))(BOOST_TYPEOF_MAKE_OBJ(elem))
-
-#define BOOST_TYPEOF_PLACEHOLDER_TYPE_PARAM(Param) int
-#define BOOST_TYPEOF_PLACEHOLDER_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param)(0)
-#define BOOST_TYPEOF_PLACEHOLDER_TEMPLATE_PARAM(Param) Nested_Template_Template_Arguments_Not_Supported
+////////////////////////////
+// move to template_encoding.hpp?
 
 //Template template registration
 #define BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE(Name,Params,ID)\
@@ -97,37 +107,11 @@ namespace boost
     };\
     typedef typename decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
 
-//'template<class,int> class' is reduced to 'class'
-#define BOOST_TYPEOF_DECLARATION_TYPE(elem)\
-    BOOST_PP_CAT(BOOST_TYPEOF_DECLARATION_TYPE_, BOOST_PP_SEQ_ELEM(0, elem))(elem)
-#define BOOST_TYPEOF_DECLARATION_TYPE_TYPE_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param)
-#define BOOST_TYPEOF_DECLARATION_TYPE_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param)
-#define BOOST_TYPEOF_DECLARATION_TYPE_TEMPLATE_PARAM(Param) class
-
 #define BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
-    BOOST_TYPEOF_DECLARATION_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(T, n)
-
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES(z,n,elem)\
-    BOOST_PP_CAT(BOOST_TYPEOF_PLACEHOLDER_TYPES_, BOOST_PP_SEQ_ELEM(0, BOOST_TYPEOF_MAKE_OBJ(elem)))(n,BOOST_TYPEOF_MAKE_OBJ(elem))
-
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES_TYPE_PARAM(n,Param) BOOST_PP_CAT(T,n)
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES_INTEGRAL_PARAM(n,Param) BOOST_PP_CAT(T,n)
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES_TEMPLATE_PARAM(n,Param) BOOST_PP_CAT(T,n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_PARAM_GETTYPE(Param),BOOST_TYPEOF_PLACEHOLDER)>
-
-
-//Category: Can this parameter be used in a template template class?
-//1 -> Simple type or integral constant
-//2 -> Template template type (can not be used to create template template template types :)
-
-#define BOOST_TYPEOF_PARAM_TT_CATEGORY(Param) \
-    BOOST_PP_CAT(BOOST_TYPEOF_TT_CATEGORY_,BOOST_PP_SEQ_ELEM(0, Param))
-#define BOOST_TYPEOF_TT_CATEGORY_INTEGRAL_PARAM 1
-#define BOOST_TYPEOF_TT_CATEGORY_TYPE_PARAM 1
-#define BOOST_TYPEOF_TT_CATEGORY_EXPLICIT_INTEGRAL_PARAM 0
-#define BOOST_TYPEOF_TT_CATEGORY_TEMPLATE_PARAM 2
+    BOOST_TYPEOF_VIRTUAL(DECLARATION_TYPE, elem)(elem) BOOST_PP_CAT(T, n)
 
 #define BOOST_TYPEOF_CHECK_TT_CATEGORY(s, data, elem)\
-    BOOST_PP_EQUAL(BOOST_TYPEOF_PARAM_TT_CATEGORY(BOOST_TYPEOF_MAKE_OBJ(elem)), data)
+    BOOST_PP_EQUAL(BOOST_TYPEOF_VIRTUAL(TT_CATEGORY, elem), data)
 
 //Check if one of the arguments is a template template argument.
 #define BOOST_TYPEOF_HAS_TEMPLATE_TEMPLATE_ARGUMENTS(Params)\
diff --git a/include/boost/typeof/compliant/type_template_param.hpp b/include/boost/typeof/compliant/type_template_param.hpp
index e951bc0..875a4f4 100755
--- a/include/boost/typeof/compliant/type_template_param.hpp
+++ b/include/boost/typeof/compliant/type_template_param.hpp
@@ -1,4 +1,5 @@
 // Copyright (C) 2005 Arkadiy Vertleyb
+// Copyright (C) 2005 Peder Holt
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
@@ -9,15 +10,20 @@
 
 // TYPE_PARAM "virtual functions" implementation
 
-#define BOOST_TYPEOF_ENCODE_TYPE_PARAM(This, n)\
+#define BOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
     typedef typename encode_type<\
         BOOST_PP_CAT(V, n),\
         BOOST_PP_CAT(P, n)\
     >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
 
-#define BOOST_TYPEOF_DECODE_TYPE_PARAM(This, n)\
+#define BOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
     typedef decode_type< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
     typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
     typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
 
+#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER(Param) int
+#define BOOST_TYPEOF_TYPE_PARAM_DECLARATION_TYPE(Param) class
+#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER_TYPES(Param, n) BOOST_PP_CAT(T,n)
+#define BOOST_TYPEOF_TYPE_PARAM_TT_CATEGORY 1
+
 #endif//BOOST_TYPEOF_COMPLIANT_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/boost/typeof/integral_template_param.hpp b/include/boost/typeof/integral_template_param.hpp
index e90210d..f441171 100755
--- a/include/boost/typeof/integral_template_param.hpp
+++ b/include/boost/typeof/integral_template_param.hpp
@@ -46,6 +46,10 @@
     (INTEGRAL_PARAM)\
     (Type)
 
-#define BOOST_TYPEOF_PARAM_EXPAND_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param)
+#define BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)\
+    BOOST_PP_SEQ_ELEM(1, Param)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_EXPANDTYPE(Param)\
+    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
 
 #endif//BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/boost/typeof/template_encoding.hpp b/include/boost/typeof/template_encoding.hpp
index e3362ea..807ea5b 100755
--- a/include/boost/typeof/template_encoding.hpp
+++ b/include/boost/typeof/template_encoding.hpp
@@ -9,6 +9,7 @@
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/seq.hpp>
 #include <boost/preprocessor/repetition/enum_trailing.hpp>
+#include <boost/preprocessor/expand.hpp>
 
 // The template parameter description, entered by the user,
 // is converted into a polymorphic "object" 
@@ -26,22 +27,20 @@
 
 // "interface"
 
-#define BOOST_TYPEOF_PARAM_ENCODE(Param)\
-    BOOST_PP_CAT(BOOST_TYPEOF_ENCODE_, BOOST_PP_SEQ_ELEM(0, Param))
-
-#define BOOST_TYPEOF_PARAM_DECODE(Param)\
-    BOOST_PP_CAT(BOOST_TYPEOF_DECODE_, BOOST_PP_SEQ_ELEM(0, Param))
-
-#define BOOST_TYPEOF_PARAM_GETTYPE(Param)\
-    BOOST_PP_SEQ_ELEM(1, Param)
-
 #define BOOST_TYPEOF_PARAM_EXPAND_TYPE(Param)\
     BOOST_PP_CAT(BOOST_TYPEOF_PARAM_EXPAND_, BOOST_PP_SEQ_ELEM(0, Param))(Param)
 
+
+//
+#define BOOST_TYPEOF_CAT_4(a, b, c, d) BOOST_TYPEOF_CAT_4_I(a, b, c, d)
+#define BOOST_TYPEOF_CAT_4_I(a, b, c, d) a ## b ## c ## d
+
+#define BOOST_TYPEOF_VIRTUAL(Fun, Obj)\
+    BOOST_TYPEOF_CAT_4(BOOST_TYPEOF_, BOOST_PP_SEQ_ELEM(0, Obj), _, Fun)
 //
 
 #define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT(z,n,seq)\
-   BOOST_PP_SEQ_ELEM(0,seq)(z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+   BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
 
 #define BOOST_TYPEOF_SEQ_ENUM(seq,macro)\
 BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
@@ -49,4 +48,13 @@ BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq
 #define BOOST_TYPEOF_SEQ_ENUM_TRAILING(seq,macro)\
 BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
 
+#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1(z,n,seq)\
+   BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+
+#define BOOST_TYPEOF_SEQ_ENUM_1(seq,macro)\
+BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+
+#define BOOST_TYPEOF_SEQ_ENUM_TRAILING_1(seq,macro)\
+BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+
 #endif//BOOST_TYPEOF_COMPLIANT_TEMPLATE_ENCODING_HPP_INCLUDED
diff --git a/include/boost/typeof/type_template_param.hpp b/include/boost/typeof/type_template_param.hpp
index c896d82..76a0d56 100755
--- a/include/boost/typeof/type_template_param.hpp
+++ b/include/boost/typeof/type_template_param.hpp
@@ -12,9 +12,8 @@
 #define BOOST_TYPEOF_MAKE_OBJ_typename BOOST_TYPEOF_TYPE_PARAM
 
 #define BOOST_TYPEOF_TYPE_PARAM\
-    (TYPE_PARAM)\
-    (class)
+    (TYPE_PARAM)
 
-#define BOOST_TYPEOF_PARAM_EXPAND_TYPE_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param)
+#define BOOST_TYPEOF_TYPE_PARAM_EXPANDTYPE(Param) class
 
 #endif//BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
diff --git a/include/boost/typeof/vintage/template_encoding.hpp b/include/boost/typeof/vintage/template_encoding.hpp
index f637a14..23259a8 100644
--- a/include/boost/typeof/vintage/template_encoding.hpp
+++ b/include/boost/typeof/vintage/template_encoding.hpp
@@ -25,51 +25,53 @@
 #define BOOST_TYPEOF_PARAM_CAST(Param)\
     BOOST_PP_CAT(BOOST_TYPEOF_CAST_, BOOST_PP_SEQ_ELEM(0, Param))
 
+//
+#define BOOST_TYPEOF_PARAM_GETTYPE(obj) BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, obj)(obj)
 // 
 
-#define BOOST_TYPEOF_ENCODE_TYPE_PARAM(This, n)\
+#define BOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
     BOOST_PP_CAT(P, n)
 
-#define BOOST_TYPEOF_DECODE_TYPE_PARAM(This, n)\
+#define BOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
     typedef typename decode_impl<TYPEOF_GET_VALUE(BOOST_PP_CAT(iter,n))>::\
         decoder<TYPEOF_GET_NEXT(BOOST_PP_CAT(iter,n))> BOOST_PP_CAT(d,n);\
     typedef typename BOOST_PP_CAT(d,n)::type BOOST_PP_CAT(P,n);\
     typedef typename BOOST_PP_CAT(d,n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
 
-#define BOOST_TYPEOF_CAST_TYPE_PARAM(This, n)\
+#define BOOST_TYPEOF_TYPE_PARAM_CAST(This, n)\
     BOOST_PP_CAT(P,n)
 
 //
 
-#define BOOST_TYPEOF_ENCODE_INTEGRAL_PARAM(This, n)\
+#define BOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
     integral_wrapper<\
         BOOST_PP_CAT(P, n)\
     >
 
-#define BOOST_TYPEOF_DECODE_INTEGRAL_PARAM(This, n)\
+#define BOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
     typedef decode_integral<BOOST_PP_CAT(iter,n)> BOOST_PP_CAT(d,n);\
     BOOST_STATIC_CONSTANT(BOOST_TYPEOF_PARAM_GETTYPE(This),BOOST_PP_CAT(P,n)=(TYPEOF_GET_VALUE(BOOST_PP_CAT(d,n))));\
     typedef typename BOOST_PP_CAT(d,n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
 
-#define BOOST_TYPEOF_CAST_INTEGRAL_PARAM(This, n)\
+#define BOOST_TYPEOF_INTEGRAL_PARAM_CAST(This, n)\
     BOOST_TYPEOF_PARAM_GETTYPE(This)(BOOST_PP_CAT(P,n))
 
-#define BOOST_TYPEOF_CAST_EXPLICIT_INTEGRAL_PARAM(This, n)\
-    BOOST_TYPEOF_PARAM_GETTYPE(This)(BOOST_PP_CAT(P,n))
+//#define BOOST_TYPEOF_CAST_EXPLICIT_INTEGRAL_PARAM(This, n)\
+//    BOOST_TYPEOF_PARAM_GETTYPE(This)(BOOST_PP_CAT(P,n))
 
 //
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
-    BOOST_TYPEOF_PARAM_DECODE(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
+    BOOST_TYPEOF_VIRTUAL(DECODE, BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
-    , BOOST_TYPEOF_PARAM_ENCODE(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
+    , BOOST_TYPEOF_VIRTUAL(ENCODE, BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(r, data, n, elem)\
     BOOST_PP_COMMA_IF(n) BOOST_TYPEOF_PARAM_GETTYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(P, n)
 
 #define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_CAST(r, data, n, elem)\
-    BOOST_PP_COMMA_IF(n) BOOST_TYPEOF_PARAM_CAST(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
+    BOOST_PP_COMMA_IF(n) BOOST_TYPEOF_VIRTUAL(CAST, BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n)
 
 //
 
diff --git a/test/compliant/test_compliant.cpp b/test/compliant/test_compliant.cpp
index 36f8c67..925c4c6 100755
--- a/test/compliant/test_compliant.cpp
+++ b/test/compliant/test_compliant.cpp
@@ -61,3 +61,4 @@ void test_spirit2()
     if (!success)
         throw 0;
 }
+#pragma message("done!")
diff --git a/test/compliant/typeof.vcproj b/test/compliant/typeof.vcproj
index 5a451c0..3e844b1 100755
--- a/test/compliant/typeof.vcproj
+++ b/test/compliant/typeof.vcproj
@@ -119,6 +119,12 @@
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
 			<File
 				RelativePath="..\main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						GeneratePreprocessedFile="0"/>
+				</FileConfiguration>
 			</File>
 			<File
 				RelativePath=".\odr1.cpp">
diff --git a/test/main.cpp b/test/main.cpp
index 73d5ccd..a50293b 100755
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -66,8 +66,7 @@ namespace template_template {
 }
 
 BOOST_TYPEOF_REGISTER_TEMPLATE_X(template_template::tt_test,(BOOST_TYPEOF_TEMPLATE( (typename)(unsigned int) ))(int))
-BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE(template_template::C,(typename)(unsigned int))
-
+BOOST_TYPEOF_REGISTER_TEMPLATE_X(template_template::C,(typename)(unsigned int))
 
 BOOST_STATIC_ASSERT((typeof_test<template_template::tt_test<template_template::C,4> >::value));
 #endif