Merge pull request #511 from pbalcer/params-cleanups

small changes for params pretty printing

Author: pbalcer

scripts/templates/helper.py

@@ -148,6 +148,10 @@ def is_flags(cls, name):
         except:
             return False
 
+    @classmethod
+    def get_flag_type(cls, name):
+        return re.sub(r"(\w+)_flags_t", r"\1_flag_t", name)
+
     @staticmethod
     def is_known(name, meta):
         try:

scripts/templates/params.hpp.mako

@@ -27,7 +27,7 @@ from templates import helper as th
     %if iname == "pNext":
         ${x}_params::serializeStruct(os, ${caller.body()});
     %elif th.type_traits.is_flags(itype):
-        ${x}_params::serializeFlag_${itype}(os, ${caller.body()});
+        ${x}_params::serializeFlag<${th.type_traits.get_flag_type(itype)}>(os, ${caller.body()});
     %elif not loop and th.type_traits.is_pointer(itype):
         ${x}_params::serializePtr(os, ${caller.body()});
     %elif loop and th.type_traits.is_pointer_to_pointer(itype):
@@ -57,7 +57,7 @@ from templates import helper as th
     %endif
     ## can't iterate over 'void *'...
     %if th.param_traits.is_range(item) and "void*" not in itype:
-        os << ".${iname} = [";
+        os << ".${iname} = {";
         for (size_t i = ${th.param_traits.range_start(item)}; ${deref}(params${access}${pname}) != NULL && i < ${deref}params${access}${prefix + th.param_traits.range_end(item)}; ++i) {
             if (i != 0) {
                 os << ", ";
@@ -66,10 +66,10 @@ from templates import helper as th
                 (${deref}(params${access}${pname}))[i]
             </%call>
         }
-        os << "]";
+        os << "}";
     %elif typename is not None:
         os << ".${iname} = ";
-        ${x}_params::serializeTaggedTyped_${underlying_type}(os, ${deref}(params${access}${pname}), ${deref}(params${access}${prefix}${typename}), ${deref}(params${access}${prefix}${typename_size}));
+        ${x}_params::serializeTagged(os, ${deref}(params${access}${pname}), ${deref}(params${access}${prefix}${typename}), ${deref}(params${access}${prefix}${typename_size}));
     %else:
         os << ".${iname} = ";
         <%call expr="member(iname, itype, False)">
@@ -80,19 +80,23 @@ from templates import helper as th
 
 namespace ${x}_params {
 template <typename T> inline void serializePtr(std::ostream &os, T *ptr);
+template <typename T> inline void serializeFlag(std::ostream &os, uint32_t flag);
+template <typename T> inline void serializeTagged(std::ostream &os, const void *ptr, T value, size_t size);
 
 %for spec in specs:
 %for obj in spec['objects']:
 ## ENUM #######################################################################
 %if re.match(r"enum", obj['type']):
     %if obj.get('typed_etors', False) is True:
-    inline void serializeTaggedTyped_${th.make_enum_name(n, tags, obj)}(std::ostream &os, const void *ptr, enum ${th.make_enum_name(n, tags, obj)} value, size_t size);
+    template <> inline void serializeTagged(std::ostream &os, const void *ptr, ${th.make_enum_name(n, tags, obj)} value, size_t size);
     %elif "structure_type" in obj['name']:
     inline void serializeStruct(std::ostream &os, const void *ptr);
     %endif
 %endif
+
+
 %if th.type_traits.is_flags(obj['name']):
-    inline void serializeFlag_${th.make_type_name(n, tags, obj)}(std::ostream &os, ${th.make_type_name(n, tags, obj)} flag);
+    template<> inline void serializeFlag<${th.make_enum_name(n, tags, obj)}>(std::ostream &os, uint32_t flag);
 %endif
 %endfor # obj in spec['objects']
 %endfor
@@ -138,7 +142,8 @@ template <typename T> inline void serializePtr(std::ostream &os, T *ptr);
     %endif
     %if obj.get('typed_etors', False) is True:
     namespace ${x}_params {
-    inline void serializeTaggedTyped_${th.make_enum_name(n, tags, obj)}(std::ostream &os, const void *ptr, enum ${th.make_enum_name(n, tags, obj)} value, size_t size) {
+    template <>
+    inline void serializeTagged(std::ostream &os, const void *ptr, ${th.make_enum_name(n, tags, obj)} value, size_t size) {
         if (ptr == NULL) {
             serializePtr(os, ptr);
             return;
@@ -157,7 +162,7 @@ template <typename T> inline void serializePtr(std::ostream &os, T *ptr);
                         %if "char" in atype: ## print char* arrays as simple NULL-terminated strings
                             serializePtr(os, tptr);
                         %else:
-                            os << "[";
+                            os << "{";
                             size_t nelems = size / sizeof(${atype});
                             for (size_t i = 0; i < nelems; ++i) {
                                 if (i != 0) {
@@ -167,7 +172,7 @@ template <typename T> inline void serializePtr(std::ostream &os, T *ptr);
                                     tptr[i]
                                 </%call>
                             }
-                            os << "]";
+                            os << "}";
                         %endif
                     %else:
                     const ${vtype} *tptr = (const ${vtype} *)ptr;
@@ -218,7 +223,9 @@ template <typename T> inline void serializePtr(std::ostream &os, T *ptr);
     %endif
 %if th.type_traits.is_flags(obj['name']):
 namespace ${x}_params {
-inline void serializeFlag_${th.make_type_name(n, tags, obj)}(std::ostream &os, ${th.make_type_name(n, tags, obj)} flag) {
+
+template<>
+inline void serializeFlag<${th.make_enum_name(n, tags, obj)}>(std::ostream &os, uint32_t flag) {
     uint32_t val = flag;
     bool first = true;
     %for n, item in enumerate(obj['etors']):

source/common/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(${PROJECT_NAME}::common ALIAS ur_common)
 
 target_include_directories(ur_common INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/include
 )
 
 add_subdirectory(unified_memory_allocation)