Added script to generate empty definitions for class members

gen_definitions.py

@@ -0,0 +1,442 @@
+#!/bin/python3
+"""
+A python script to generate toString functions for all enumerations in a cpp file.
+Copyright  ©  2022  Matthias  Quintern.
+This software comes with no warranty.
+This software is licensed under the GPL3
+"""
+from os import path, listdir, chdir
+from sys import argv, exit
+import re
+
+
+# search in header files for enums 
+header_filetypes = [".hpp"]
+# definition are written to source file having the same name as the header
+source_filetype = ".cpp"
+
+def error(s):
+    print(s)
+    exit(1)
+
+constexpr = "constexpr"
+inline = "inline"
+static = "static"
+
+def template_str2list(s:str):
+    if s:
+        templates = s.removeprefix("template<").removesuffix(">").split(", ")
+        templates = [ t.split(" ") for t in templates ]
+    else:
+        templates = []
+    return templates
+
+def template_list2str(t:list[tuple[str, str]], req:str=""):
+    if len(t) == 0:
+        return ""
+    s = "template<"
+    for temp in t:
+        s += temp[0] + " " + temp[1] + ", "
+    s = s.removesuffix(", ") + ">\n"
+    if req:
+        s += "\t" + "requires " + req
+    return s
+
+def transformString(s: str, depth: int):
+    """Add tabs after all but the last line break and before the first char.
+    Do not add tabs to lines that start with a label"""
+    new_s = ""
+    for line in s.split("\n"):
+        if re.fullmatch(r"\w+:[^:].*", line) is None:
+            new_s += depth * "\t";
+        new_s += line + "\n"
+    new_s = new_s.removesuffix("\n").removesuffix(depth*"\t")
+    # return depth * tab + s.replace("\n", "\n" + depth * tab, s.count("\n") - 1)
+    return new_s
+
+
+class Member:
+    def __init__(self, name:str, m_temp:list=[], prefixes:list=[], ret_type:str="", args:str="", init:str="", requires:str="", const=False, defined=False, is_value=False, namespace:str=""):
+        """
+        :param name: member name
+        :param m_temp: list of templates of the member
+        :param prefixes:  things like constexpr, inline...
+        :param ret_type: return type of the member
+        :param args: arguments of the member
+        :param init: initializion of the member
+        :param requires: constraints on template types
+        :param const: True if the method does not change the object
+        :param defined: method defined
+        :param is_value: wether the member is a value or a method
+
+        template<c_temp>
+        class class {
+            comment
+            template<m_temp>
+            prefixes ret_type name(args) const : init {
+                body
+            }
+        }
+        """
+        self.name = name
+        self.prefixes = prefixes
+        self.m_temp = m_temp
+        self.ret_type = ""
+        if ret_type: self.ret_type = ret_type + " "
+        self.args = args
+        self.init = ""
+        if init: self.init = f"\n\t : {init} "
+        self.requires = requires
+        self.const = ""
+        if const: self.const = " const"
+        self.defined = defined
+        self.comment = ""
+        # if comment:
+        #     if type(comment) == str:
+        #         self.comment = "/// " + comment + "\n"
+        #     elif type(comment) == dict:
+        #         self.comment = comment_from_dict(comment)
+        self.is_value = is_value
+        self.namespace = namespace
+
+    def getArgsAsList(self):
+        args = []
+        const = False
+        arglist = self.args.split(", ")
+        for i in range(len(arglist)):
+            if "const" in arglist[i]:
+                arglist[i] = arglist[i].replace("const ", "")
+                const = True
+            args.append(arglist[i].split(" "))
+            if const:
+                args[-1][0] = "const " + args[-1][0]
+        return args
+
+    def get_source_name(self, c_temp=[], class_=""):
+        s = ""
+        if class_:
+            if len(c_temp) > 0:
+                class_ = class_ + "<"
+                for t in c_temp:
+                    class_ += f"{t[1]}, "
+                class_ = class_.removesuffix(", ") + ">"
+            class_ += "::"
+
+        s += template_list2str(self.m_temp, self.requires)
+        for p in self.prefixes:
+            s += p + " "
+
+        if self.is_value:
+            if static in self.prefixes and not constexpr in self.prefixes:
+                s += f"{self.ret_type}{class_}{self.name};\n"
+                return s
+            else:
+                s += f"{self.ret_type}{class_}{self.name};\n"
+                return s
+        s += f"{self.ret_type}{class_}{self.name}({self.args}){self.const}"
+        return s
+
+    def source(self, c_temp=[], class_="", depth:int=0):
+        """
+        Return the empty defition + declarations for a source file
+        """
+        s = ""
+        if class_:
+            s += template_list2str(c_temp)
+            if len(c_temp) > 0:
+                class_ = class_ + "<"
+                for t in c_temp:
+                    class_ += f"{t[1]}, "
+                class_ = class_.removesuffix(", ") + ">"
+            class_ += "::"
+
+        s += template_list2str(self.m_temp, self.requires)
+        for p in self.prefixes:
+            s += p + " "
+
+        if self.is_value:
+            if static in self.prefixes and not constexpr in self.prefixes:
+                s += f"{self.ret_type}{class_}{self.name};\n"
+                return s
+            else:
+                return ""
+
+        s += f"{self.ret_type}{class_}{self.name}({self.args}){self.const}{self.init}" + " {\n\t\n}\n"
+            # s += " {\n"
+            # body = ""
+            # for l in self.body: body += l + "\n"
+            # s += transformString(body, depth)
+            # s += "}\n"
+        # else:
+            # s += "{}"
+        return transformString(s, depth)
+
+    def __repr__(self):
+        return self.get_source_name([], "")
+
+
+class Class:
+    def __init__(self, name: str, c_temp: list[str]):
+        self.member_functions: list[Member] = []
+        self.member_variables: list[Member] = []
+        self.name = name
+        self.c_temp: list[str] = c_temp
+
+
+#
+# regex
+#
+# s must be a string where all indentation was removed
+# COMMENTS
+def starts_with_normal_comment(s: str) -> bool:
+    if re.search(r"^(//|/?\*)[^*/]", s): return True
+    else: return False
+
+def starts_with_doxygen_comment(s: str) -> bool:
+    if re.search(r"^(///|/\*\*)", s): return True
+    else: return False
+
+def starts_with_comment(s: str) -> bool:
+    return starts_with_normal_comment(s) or starts_with_doxygen_comment(s);
+
+def starts_with_comment_end(s: str) -> bool:
+    if re.search(r"^(\*/)", s): return True
+    else: return False
+
+# NAMESPACE
+def namespace_open(s: str) -> tuple[bool, str]:
+    match = re.search(r"^namespace (\w+) *{", s)
+    if match:
+        return True, match.groups()[0]
+    return False, ""
+
+
+# TEMPLATE
+def template_declaration(s: str) -> bool:
+    if re.search(r"^template<(.+)>", s):
+        return True
+    return False
+
+# CLASS DECLARATION
+def class_declaration(s: str) -> tuple[bool, str]:
+    match = re.search(r"^class (\w+)", s)
+    if match:
+        return True, match.groups()[0]
+    return False, ""
+
+# VARIABLE/MEMBER DECLARATION
+def variable_declaration(s: str, template_str:str = "", namespace:str="") -> tuple[bool, Member]:
+    match = re.search(r"^(\w+ )+(\w+)( *= *.+)? *;", s)
+    # match = re.search(r"^((?:\w+ )+)(\w+) *(const)? *;", s)  # declration
+    if match:
+        g = match.groups()
+        prefixes = []
+        ret_type = ""
+        if g[2]: defined = True
+        else: defined = False
+        # get ret_type and prefixes
+        for prefix in g[0].strip(" ").split(" "):
+            if prefix in ["const", "constexpr", "inline", "static"]:
+                prefixes.append(prefix)
+            else:
+                ret_type += prefix + " "
+        return True, Member(g[1], m_temp=template_str2list(template_str), prefixes=prefixes, ret_type=ret_type, is_value=True, defined=defined, namespace=namespace)
+    return False, Member("")
+
+# FUNCTION DECLARATION
+def function_declaration(s: str, template_str:str = "", namespace: str="") -> tuple[bool, Member]:
+    match = re.search(r"^((?:\w+ )+)(\w+)\(((?:\w+ )*(?:\w+))?\) *(const)? *;", s)  # declration
+    if match is None:
+        match = re.search(r"^((?:\w+ )+)(?:\w+)\(((?:\w+ )*(?:\w+))?\) *(const)? * *{", s)  # declaration with definition
+        defined = True
+    else:
+        defined = False
+    if match:
+        g = match.groups()
+        prefixes = []
+        ret_type = ""
+        # get ret_type and prefixes
+        for prefix in g[0].strip(" ").split(" "):
+            if prefix in ["const", "constexpr", "inline", "static"]:
+                prefixes.append(prefix)
+            else:
+                ret_type += prefix + " "
+        ret_type = ret_type.strip(" ")
+        if g[2]: args = g[2]
+        else: args = ""
+        if g[3]: const = True
+        else: const = False
+
+
+        ret_type = ""
+        return True, Member(g[1], template_str2list(template_str), prefixes=prefixes, ret_type=ret_type, args=args, defined=defined, const=const, namespace=namespace)
+    return False, Member("")
+
+
+#
+# INDENTATION
+# 
+def get_indentation(s_indentation: str) -> int:
+    """
+    returns number of spaces
+    """
+    return s_indentation.replace("\t", "    ").count(" ")
+
+def get_string_and_indent(s: str) -> tuple[str, int]:
+    """
+    returns the string without indentation and the number of spaces in the indentation
+    """
+    match = re.search("^([ \t]*)", s)
+    if match:
+        return s[len(match.groups()[0]):], get_indentation(match.groups()[0])
+    return s, 0
+
+
+# SCOPE END
+def scope_end(s: str) -> bool:
+    if re.search(r"^}", s):
+        return True
+    return False
+
+def parse_header(header_file:str):
+    with open(header_file, "r") as file:
+        header = file.readlines()
+
+    declarations: list[Class | Member] = []
+
+    template_str = ""
+    scopes : list[tuple[str, str, int, int]] = []   # type (eg class, namespace...), name, indentation, line
+    in_class = ""
+    namespace = ""
+
+    for i in range(len(header)):
+        line, indent = get_string_and_indent(header[i])
+        if starts_with_normal_comment(line): continue
+        if starts_with_doxygen_comment(line):
+            pass
+        if starts_with_comment_end(line):
+            pass
+
+        if template_declaration(line):
+            template_str = line
+
+        match, name = namespace_open(line)
+        if match:
+            scopes.append(("namespace", name, indent, i))
+            namespace += "::" + name
+            namespace = namespace.strip("::")
+
+        match, name = class_declaration(line)
+        if match:
+            # print("class in", i, "-", name)
+            scopes.append(("class", name, indent, i))
+            declarations.append(Class(name, c_temp=template_str2list(template_str)))
+            in_class = name
+            # declarations[-1].members.append(member_from_str(line, template_str))
+        match, member = function_declaration(line, template_str, namespace)
+        if match:
+            # print("function in", i, "-", member.get_source_name([], ""))
+            if in_class:
+                declarations[-1].member_functions.append(member)
+            else:
+                declarations.append(member)
+            template_str = ""
+        match, member = variable_declaration(line, template_str, namespace)
+        if match:
+            # print("variable in", i, "-", member.get_source_name([], ""))
+            if in_class:
+                declarations[-1].member_variables.append(member)
+            else:
+                declarations.append(member)
+            template_str = ""
+
+        if scope_end(line):
+            if len(scopes) > 0 and scopes[-1][2] == indent:
+                if (scopes[-1][0] == "namespace"):
+                    for i in range(len(namespace)):
+                        if namespace[-i-1] == ":":
+                            namespace = namespace[:-i-2]
+                            break;
+                scopes.pop()
+            else:
+                # print("WARNING: Found scope end but no scope was opened at this indentaiton. line:", i)
+                pass
+    return declarations
+
+
+def get_definition(declarations: list[Class | Member], target_name: str):
+    member = None
+    for dec in declarations:
+        if type(dec) == Class:
+            for mem in dec.member_functions:
+                if mem.name in target_name:
+                    return mem.source(dec.c_temp, dec.name, len(mem.namespace.split("::")))
+        else:
+            if dec.name in target_name:
+                return dec.source([], "", len(dec.namespace.split("::")))
+
+    return ""
+
+
+def print_help():
+    print("""
+Synposis:           gen_definitions.py <Options>... --file <file> --name <name>
+-h --help           help
+--getter
+--setter
+--getter-and-setter
+--def
+--name <name>
+--file <file>
+--no-docs           turn off docstring generation
+""")
+
+# def missing_arg(arg):
+#     print("Missing argument for", arg)
+#     exit(1)
+
+if __name__ == "__main__":
+    docs = True
+    getter = False
+    setter = False
+    definition = False
+    file = ""
+    target_name = ""
+    i = 1
+    while i in range(1, len(argv)):
+        if  argv[i] == "--help" or argv[i] == "-h":
+            print_help()
+            exit(0)
+        elif argv[i] == "--getter-and-setter":
+            getter = True
+            setter = True
+        elif argv[i] == "--getter":
+            getter = True
+        elif argv[i] == "--setter":
+            setter = True
+        elif argv[i] == "--def":
+            definition = True
+            interactive = True
+        elif argv[i] == "--no-docs":
+            docs = False
+        elif argv[i-1] == "--file":
+            file = argv[i]
+        elif argv[i-1] == "--name":
+            target_name = argv[i]
+        i += 1
+
+    ret = ""
+    declarations = []
+    if file:
+        if path.isfile(file):
+            declarations = parse_header(file)
+        else:
+            # print("Not a file:", file)
+            exit(1)
+    if getter:
+        pass
+    if setter:
+        pass
+    if definition:
+        print(get_definition(declarations, target_name))
+