Dear ImGui v1.92.0 compatibility fixes

Author: ShironekoBen

dear_bindings.py

@@ -1,4 +1,4 @@
-# Dear Bindings Version v0.13
+# Dear Bindings Version v0.14
 # Generates C-language headers for Dear ImGui
 # Developed by Ben Carter (e-mail: ben AT shironekolabs.com, github: @ShironekoBen)
 
@@ -185,7 +185,20 @@ def convert_header(
                                           "ImGui::DragBehaviorT",
                                           "ImGui::SliderBehaviorT",
                                           "ImGui::RoundScalarWithFormatT",
-                                          "ImGui::CheckboxFlagsT"])
+                                          "ImGui::CheckboxFlagsT",
+                                          # This is a slightly awkward one - there are two problems here. One is that
+                                          # the function stub generator goes back to the original parsed code when
+                                          # trying to generate casts and ends up using the un-instantiated template
+                                          # parameter T as the target for a cast. That is fixable, but the other issue
+                                          # is that it takes a const& to the element to push, and in the sole existing
+                                          # usage right now that's a ImFontBaked, which isn't an easy thing for the
+                                          # structure marshalling to handle. Really it should probably be fudged to
+                                          # take a pointer instead of const& or similar, as passing ImFontBaked by
+                                          # value isn't really a sensible thing to be doing in the first place, but
+                                          # for the moment I don't think there's actually any use-case for wanting to
+                                          # add things to BakedPool from outside of ImGui itself, so I'm going to
+                                          # adopt a wait-and-see stance on this for now.
+                                          "ImStableVector::push_back"])
 
     mod_remove_functions.apply(dom_root, ["ImGui::GetInputTextState",
                                           "ImGui::DebugNodeInputTextState"])
@@ -306,12 +319,14 @@ def convert_header(
     mod_mark_by_value_structs.apply(dom_root, by_value_structs=[
         'ImVec1',
         'ImVec2',
+        'ImVec2i',
         'ImVec2ih',
         'ImVec4',
         'ImColor',
         'ImStr',
         'ImRect',
-        'ImGuiListClipperRange'
+        'ImGuiListClipperRange',
+        'ImTextureRef'
     ])
     mod_mark_internal_members.apply(dom_root)
     mod_flatten_class_functions.apply(dom_root)

docs/Changelog.txt

@@ -1,3 +1,12 @@
+--- v0.14
+
+* Fixes for compatibility with Dear ImGui v1.92.0.
+* Refactored template support so that ImStableVector<> doesn't cause errors (at present ImStableVector::push_back()
+  is not supported as there are complications with that function, but I don't think there's actually a use-case for
+  modifying ImStableVector contents from outside ImGui right now anyway). (#98)
+* Marked ImVec2i and ImTextureRef as by-value structure types.
+* Parsing support for loose member function bodies.
+
 --- v0.13
 
 * Cosmetic fix to the naming of the PlatformIO thunk helper functions, and made the comment more explicit about why

src/code_dom/element.py

@@ -290,6 +290,14 @@ def is_descendant_of(self, parent):
             return False
         return self.parent.is_descendant_of(parent)
 
+    # Tests if this element is a descendant of (or the same as) the type given
+    def is_descendant_of_type(self, element_type):
+        if isinstance(self, element_type):
+            return True
+        if self.parent is None:
+            return False
+        return self.parent.is_descendant_of_type(element_type)
+
     # Walk this element and all children, calling a function on them
     def walk(self, func):
         func(self)

src/code_dom/fielddeclaration.py

@@ -6,7 +6,7 @@
 class DOMFieldDeclaration(code_dom.element.DOMElement):
     def __init__(self):
         super().__init__()
-        self.field_type = None
+        self.field_type = None  # A DOMType giving the type of the field
         self.names = []
         self.is_static = False
         self.is_extern = False

src/code_dom/functiondeclaration.py

@@ -35,8 +35,9 @@ def __init__(self):
         #                                (see mod_generate_imstr_helpers for more details)
 
         self.function_name_alignment = 0  # Column to align the function name to (see mod_align_function_names)
-        self.is_unformatted_helper = False # Set if this is a variant of a function accepting a format string with
+        self.is_unformatted_helper = False  # Set if this is a variant of a function accepting a format string with
         #                                  format string forced to '%s' and a single string argument
+        self.is_loose_function_body = False  # Set if this is a "loose" inline function body in the header file
 
     # Parse tokens from the token stream given
     @staticmethod
@@ -109,6 +110,30 @@ def parse(context, stream):
             return None
         dom_element.tokens.append(name_token)
 
+        # We potentially actually might have a class name here, so if this is followed by :: then the real name
+        # comes after it
+
+        if stream.get_token_of_type(["COLON"]) is not None:
+            if stream.get_token_of_type(["COLON"]) is None:
+                # Function name followed by a single colon isn't valid
+                stream.rewind(checkpoint)
+                return None
+
+            # At this point we know we have something of the form ClassName::FunctionName
+            # For the time being, treat that as the actual function name (we are likely just going to throw this
+            # away as it is guaranteed to be a function body with an actual declaration elsewhere)
+
+            actual_name_token = stream.get_token_of_type(["THING"])
+            if actual_name_token is None:
+                # ClassName:: with no actual function name isn't valid
+                stream.rewind(checkpoint)
+                return None
+            dom_element.tokens.append(actual_name_token)
+
+            dom_element.is_loose_function_body = True
+            name_prefix = name_token.value + "::" + name_prefix
+            name_token = actual_name_token
+
         if name_token.value == "operator":
             # If we got "operator" then we need to read the real name from the next tokens too
             # (tokens because of things like "operator[]" and "operator*=")

src/code_dom/template.py

@@ -70,6 +70,17 @@ def parse(context, stream):
                 # template<> only has a single (non-comment-like) child, so stop here
                 break
 
+        # Now we have parsed all our children, we want to mark any types we contain that are our own template parameters
+
+        template_params = dom_element.get_template_parameters()
+
+        for type_element in dom_element.list_all_children_of_type(code_dom.DOMType):
+            for token in type_element.tokens:
+                for param in template_params:
+                    if token.value == param.name:
+                        # Slightly hacky - set this on the token itself
+                        token.is_template_parameter = True
+
         return dom_element
 
     # Get the class/function this template is for
@@ -79,6 +90,33 @@ def get_templated_object(self):
                 return child
         return None
 
+    class TemplateParameter:
+        def __init__(self):
+            super().__init__()
+            self.is_typename = False  # Is this a typename parameter?
+            self.name = None  # The name of this parameter
+
+    # Figure out the template parameters via some dubious parsing
+    # Returns a list of DOMTemplate.TemplateParameter objects
+    def get_template_parameters(self):
+        template_parameters = []
+        next_parameter_is_typename = False
+        for token in self.template_parameter_tokens:
+            if token.value == 'typename':
+                next_parameter_is_typename = True
+            elif token.value == 'int':
+                next_parameter_is_typename = False
+            elif token.type == 'COMMA':
+                # Just ignore
+                pass
+            else:
+                # This must be a template parameter name
+                param = DOMTemplate.TemplateParameter()
+                param.is_typename = next_parameter_is_typename
+                param.name = token.value
+                template_parameters.append(param)
+        return template_parameters
+
     # Write this element out as C code
     def write_to_c(self, file, indent=0, context=WriteContext()):
         self.write_preceding_comments(file, indent, context)

src/code_dom/type.py

@@ -111,6 +111,21 @@ def is_constexpr(self):
                 return True
         return False
 
+    # Returns true if this type is a pointer
+    # Only considers the "outermost" type
+    def is_pointer(self):
+        if len(self.tokens) > 0:
+            if self.tokens[-1].type == 'ASTERISK':
+                return True
+        return False
+
+    # Return true if there are any (unresolved) template parameters in this type
+    def contains_template_parameters(self):
+        for tok in self.tokens:
+            if hasattr(tok, 'is_template_parameter') and tok.is_template_parameter:
+                return True
+        return False
+
     # Gets the "primary" type name involved (i.e. without any prefixes or suffixes)
     # This is mostly useful for trying to construct overload disambiguation suffixes
     def get_primary_type_name(self):

src/generators/gen_struct_converters.py

@@ -4,8 +4,8 @@
 from src.code_dom.common import write_c_line, WriteContext
 
 
-# Recursively generate code to copy all the members of a struct and any contained by-valuestructs
-def generate_field_copies(file, indent, known_by_value_structs, struct, prefix):
+# Recursively generate code to copy all the members of a struct and any contained by-value structs
+def generate_field_copies(file, indent, known_by_value_structs, struct, prefix, to_cpp):
     # Emit code to copy each member
     for field in struct.list_directly_contained_children_of_type(code_dom.DOMFieldDeclaration):
         if field.field_type.to_c_string() in known_by_value_structs:
@@ -15,10 +15,23 @@ def generate_field_copies(file, indent, known_by_value_structs, struct, prefix):
                                       indent,
                                       known_by_value_structs,
                                       known_by_value_structs[field.field_type.to_c_string()],
-                                      prefix + name + ".")
+                                      prefix + name + ".",
+                                      to_cpp)
         else:
             for name in field.names:
-                write_c_line(file, indent, WriteContext(), "dest." + prefix + name + " = src." + prefix + name + ";")
+                if field.field_type.is_pointer():
+                    # Pointer-type fields need casting
+                    if to_cpp:
+                        cast_type = "::" + field.field_type.to_c_string()
+                    else:
+                        cast_type = "cimgui::" + field.field_type.to_c_string()
+
+                    write_c_line(file, indent, WriteContext(),
+                                 "dest." + prefix + name + " = reinterpret_cast<" + cast_type + ">(src." +
+                                 prefix + name + ");")
+                else:
+                    write_c_line(file, indent, WriteContext(), "dest." + prefix + name + " = src." + prefix + name +
+                                 ";")
 
 
 # Generate code to convert by-value types to/from their CPP version
@@ -55,7 +68,7 @@ def generate(dom_root, file, indent=0):
                 write_c_line(file, indent, write_context, dest_type + " dest;")
 
                 # Emit code to copy each member
-                generate_field_copies(file, indent, known_by_value_structs, struct, "")
+                generate_field_copies(file, indent, known_by_value_structs, struct, "", to_cpp)
 
                 write_c_line(file, indent, write_context, "return dest;")
                 indent -= 1