lbkit 0.5.20__tar.gz → 0.5.23__tar.gz

{lbkit-0.5.20/lbkit.egg-info → lbkit-0.5.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.20
+Version: 0.5.23
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com
@@ -16,7 +16,7 @@ Requires-Dist: colorama
 Requires-Dist: mako
 Requires-Dist: node-semver==0.6.1
 Requires-Dist: jsonschema
-Requires-Dist: conan==2.1
+Requires-Dist: conan
 Requires-Dist: requests
 Requires-Dist: gitpython
 Requires-Dist: inflection

lbkit-0.5.23/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.5.23'

lbkit-0.5.23/lbkit/build_conan_parallel.py

@@ -0,0 +1,197 @@
+"""任务基础类"""
+import os
+import json
+from queue import Queue
+from threading import Thread
+from lbkit.log import Logger
+from lbkit.errors import LiteBmcException
+from lbkit import misc
+from lbkit.tools import Tools
+
+tools = Tools("comp_build")
+log = Logger("comp_build")
+
+class ConanPackage():
+    def __init__(self, node):
+        self.node = node
+        self.deps: dict[str, ConanPackage] = {}
+        self.build_deps: dict[str, ConanPackage] = {}
+        self.ref = node.get("ref")
+        self.pkg = self.ref.split("#")[0]
+        self.name = self.pkg.split("/")[0]
+        self.context = node.get("context")
+        self.building = False
+        self.is_host = self.context == "host"
+        binary = node.get("binary")
+        self.binary_exist = (binary in ["Cache"])
+
+    def append_dep(self, dep):
+        self.deps[dep.pkg] = dep
+
+    def append_build_dep(self, dep):
+        self.build_deps[dep.pkg] = dep
+
+    # 间接构建依赖更新为直接依赖
+    def update_indirect_build_dep(self):
+        deps = {}
+        for _, dep in self.build_deps.items():
+            sub_deps = dep.update_indirect_build_dep()
+            deps.update(sub_deps)
+        self.build_deps.update(deps)
+        return self.build_deps
+
+    @property
+    def options(self):
+        return self.node.get("options", {})
+
+    @property
+    def settings(self):
+        return self.node.get("settings", {})
+
+    @property
+    def default_options(self):
+        return self.node.get("default_options", {})
+
+
+class BuildConanParallel(object):
+    def __init__(self, graphinfo, lockfile, cmd, force_build):
+        self.queue = Queue()
+        self.cmd = ""
+        chunks = cmd.split()
+        skip = False
+        for chunk in chunks:
+            if skip:
+                skip = False
+                continue
+            if chunk in ["--user", "--channel", "--version", "--name"]:
+                skip = True
+                continue
+            self.cmd += f"{chunk} "
+        self.graphinfo = os.path.realpath(graphinfo)
+        self.lockfile = os.path.realpath(lockfile)
+        if not os.path.isfile(graphinfo):
+            raise LiteBmcException(f"graph file {graphinfo} not exist")
+        self.exception = None
+        self.force_build = force_build
+
+    def build_dep(self, cp: ConanPackage, options):
+        for name, value in cp.settings.items():
+            options += f" -s {name}={value}"
+
+        cmd = f"conan install --requires={cp.ref} {self.cmd} {options}"
+        if self.force_build:
+            cmd += f" --build=\"{cp.name}/*\""
+        cmd += " --build=missing"
+        cmd += f" --lockfile={self.lockfile}"
+        try:
+            log.info(f">>>> build {cp.ref} start")
+            log.debug(f">>>> {cmd}")
+            tools.exec(cmd, echo_cmd=False, log_name=f"{misc.LOG_DIR}/conan_{cp.name}.log")
+            log.success(f"<<<< build {cp.ref} finished")
+        except Exception as e:
+            self.exception = e
+        self.queue.put(cp)
+
+    def build(self):
+        with open(self.graphinfo, "r") as fp:
+            grapth = json.load(fp)
+        nodes = grapth.get("graph", {}).get("nodes", {})
+        packages: dict[str, ConanPackage] = {}
+
+        build_works = {}
+        for id, node in nodes.items():
+            if id == "0":
+                continue
+            cp = ConanPackage(node)
+            packages[cp.pkg] = cp
+            build_works[cp.name] = False
+        for id, node in nodes.items():
+            if id == "0":
+                continue
+            ref = node.get("ref")
+            if ref.startswith("litebmc/"):
+                continue
+            cp = packages[ref.split("#")[0]]
+            deps = node.get("dependencies", {})
+            for _, dep in deps.items():
+                dep_ref = dep.get("ref")
+                direct = dep.get("direct")
+                if not direct:
+                    continue
+                dep_cp = packages[dep_ref]
+                if dep_cp.is_host:
+                    cp.append_dep(dep_cp)
+                else:
+                    cp.append_build_dep(dep_cp)
+        options = ""
+        for _, cp in packages.items():
+            for name, value in cp.options.items():
+                if value is None:
+                    continue
+                def_val = cp.default_options.get(name)
+                conan_name = cp.pkg.split("@")[0]
+                if isinstance(def_val, bool):
+                    if (def_val and "False" == value) or (not def_val and "True" == value):
+                        options += f" -o {conan_name}:{name}={value}"
+                elif def_val != value:
+                    options += f" -o {conan_name}:{name}={value}"
+        # 工具间接依赖变更为直接依赖
+        for name, pkg in packages.items():
+            pkg.update_indirect_build_dep()
+        wait_finished = 0
+        while True:
+            for _, cp in packages.items():
+                if wait_finished >= 4:
+                    continue
+                if cp.ref.startswith("litebmc/"):
+                    continue
+                # 如果是构建工具，不参与构建
+                if not cp.is_host:
+                    continue
+                # 如果还有依赖未构建完成，不参与构建
+                if len(cp.deps) != 0:
+                    continue
+                # 如果正在构建
+                if cp.building:
+                    continue
+                # 相同名称的组件正在构建时不启动新的构建
+                if build_works[cp.name]:
+                    continue
+                if not cp.binary_exist or self.force_build:
+                    # 当依赖的构建工具存在正在构建的组件时不能构建
+                    need_build = True
+                    for _, dep in cp.build_deps.items():
+                        # 正在构建且未构建出制品时
+                        if not dep.binary_exist and dep.building:
+                            need_build = False
+                            break
+                    if not need_build:
+                        continue
+                    cp.building = True
+                    # 启动构建前将其依赖的构建工具置为正在构建
+                    for _, dep in cp.build_deps.items():
+                        dep.building = True
+                    build_works[cp.name] = True
+                    wait_finished += 1
+                    thread = Thread(target=self.build_dep, args=(cp, options,))
+                    thread.start()
+                else:
+                    cp.building = True
+                    build_works[cp.name] = True
+                    wait_finished += 1
+                    self.queue.put(cp)
+            if not wait_finished:
+                return
+            cp = self.queue.get()
+            if self.exception:
+                raise self.exception
+            build_works[cp.name] = False
+            wait_finished -= 1
+            for _, sub_cp in packages.items():
+                if sub_cp.deps.get(cp.pkg):
+                    sub_cp.deps.pop(cp.pkg)
+            # 构建完成后，组件的构建依赖工具一定构建完成且制品存在
+            for _, dep in cp.build_deps.items():
+                dep.building = False
+                dep.binary_exist = True
+

{lbkit-0.5.20 → lbkit-0.5.23}/lbkit/cli.py

@@ -57,8 +57,12 @@ class Command(object):
 
         支持自动生成服务端和客户端C代码
         """
-        gen = CodeGen(sys.argv[2:])
-        gen.run("./metadata/package.yml")
+        argv = sys.argv[2:]
+        if "-i" not in argv and "-c" not in argv:
+            if os.path.isfile("./metadata/package.yml"):
+                argv.extend(["-c", "./metadata/package.yml"])
+        gen = CodeGen(argv)
+        gen.run()
 
     # new package
     def new(self, *args):
@@ -220,19 +224,23 @@ class Command(object):
 
             method(args[0][1:])
         except KeyboardInterrupt as exc:
+            log.error("lbk exit with exception:")
             log.error(exc)
             ret_code = 0
         except SystemExit as exc:
+            log.error("lbk exit with exception:")
             if exc.code != 0:
                 log.error("Exiting with code: %d" % exc.code)
             ret_code = exc.code
         except (errors.LiteBmcException, errors.RunCommandException, errors.ArgException, errors.PackageConfigException, Exception, errors.OdfValidateException) as exc:
+            log.error("lbk exit with exception:")
             if os.environ.get("LOG"):
                 print(traceback.format_exc())
             ret_code = -1
             msg = str(exc)
             log.error(misc.Color.RED + msg + misc.Color.RESET_ALL)
         except errors.TestException:
+            log.error("lbk exit with exception:")
             log.error(exc)
             ret_code = -1
 

{lbkit-0.5.20 → lbkit-0.5.23}/lbkit/codegen/codegen.py

@@ -17,11 +17,12 @@ from lbkit.misc import SmartFormatter
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 log = Logger("codegen")
 
-__version__=2
+__version__=3
 
 class CodeGen(object):
     def __init__(self, args):
         self.args = args
+        self.codegen_version = __version__
         pass
 
     def _gen(self, idf_file, directory="."):
@@ -32,12 +33,12 @@ class CodeGen(object):
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
         interface = IdfInterface(lookup, idf_file)
         out_file = os.path.join(directory, "public", interface.name + ".xml")
-        interface.render_dbus_xml("interface.introspect.xml.mako", out_file)
+        interface.render_dbus_xml("interface.introspect.xml.mako", out_file, self.codegen_version)
         for code_type in ["server", "client", "public"]:
             out_file = os.path.join(directory, code_type, interface.name + ".h")
-            interface.render_c_source(code_type + ".h.mako", out_file)
+            interface.render_c_source(code_type + ".h.mako", out_file, self.codegen_version)
             out_file = os.path.join(directory, code_type, interface.name + ".c")
-            interface.render_c_source(code_type + ".c.mako", out_file)
+            interface.render_c_source(code_type + ".c.mako", out_file, self.codegen_version)
         json_file = os.path.join(directory, "package.yml")
         data = {
             "version": interface.version,
@@ -54,37 +55,59 @@ class CodeGen(object):
             json.dump(odf_data, fp, sort_keys=False, indent=4)
 
 
-    def run(self, package_yml=None):
+    def run(self):
         """
         代码自动生成.
 
         支持自动生成服务端和客户端C代码
         """
-        if package_yml is not None and os.path.isfile(package_yml):
-            configs = Helper.read_yaml(package_yml, "codegen", [])
+        parser = argparse.ArgumentParser(description=self.run.__doc__,
+                                         prog="lbkit gen",
+                                         formatter_class=SmartFormatter)
+        # 默认的自动生成工具版本号为2
+        parser.add_argument("-cv", "--codegen_version", help=f'''must less than or equal to {__version__}, default: 2
+                            description of changes:
+                            3: compatible with lb_base/0.7.x
+                            2: compatible with lb_base/0.6.x
+                            ''',
+                            type=int, default=2)
+        parser.add_argument("-d", "--directory", help='generate code directory', default=".")
+        group2 = parser.add_argument_group('cdf file', 'Generate code using the specified CDF file')
+        group2.add_argument("-c", "--cdf_file", help='component description file, default metadata/package.yml', default=None)
+        group1 = parser.add_argument_group('idf file', 'Generate code using the specified IDF file')
+        group1.add_argument("-i", "--idf_file", help='A IDF file to be processed e.g.: com.litebmc.Upgrade.xml', default=None)
+
+        args = parser.parse_args(self.args)
+
+        if args.cdf_file:
+            if not os.path.isfile(args.cdf_file):
+                raise ArgException(f"argument -c/--cdf_file: {args.cdf_file} not exist")
+            configs = Helper.read_yaml(args.cdf_file, "codegen", [])
+            # 为保障兼容，package.yml未指定版本号的，默认使用2，该版本配套lb_base/0.6.0版本，其LBProperty无set/get成员
+            self.codegen_version = Helper.read_yaml(args.cdf_file, "codegen_version", 2)
             for cfg in configs:
                 file = cfg.get("file")
                 if file is None:
-                    log.error("%s的自动代码生成配置不正确, 缺少file元素指定描述文件", package_yml)
+                    log.error("%s的自动代码生成配置不正确, 缺少file元素指定描述文件", args.cdf_file)
                     sys.exit(-1)
                 if not file.endswith(".yaml") :
-                    log.error("%s的自动代码生成配置不正确, %s的文件名不是以.yaml结束", package_yml, file)
+                    log.error("%s的自动代码生成配置不正确, %s的文件名不是以.yaml结束", args.cdf_file, file)
                     sys.exit(-1)
                 if not os.path.isfile(file):
-                    log.error("%s的自动代码生成配置不正确, %s不是一个文件", package_yml, file)
+                    log.error("%s的自动代码生成配置不正确, %s不是一个文件", args.cdf_file, file)
                     sys.exit(-1)
                 outdir = cfg.get("outdir", os.getcwd())
                 self._gen(file, outdir)
             return
 
-        parser = argparse.ArgumentParser(description=self.run.__doc__,
-                                         prog="lbkit gen",
-                                         formatter_class=SmartFormatter)
-        parser.add_argument("-i", "--input", help='A IDF file to be processed e.g.: com.litebmc.Upgrade.xml', required=True)
-        parser.add_argument("-d", "--directory", help='generate code directory', default=".")
-
-        args = parser.parse_args(self.args)
-        intf_file = args.input
+        intf_file = args.idf_file
+        if not intf_file:
+            raise ArgException(f"argument error, arguments -c/--cdf_file and -i/--idf_file are not set")
+        if not os.path.isfile(intf_file):
+            raise ArgException(f"argument -i/--idf_file: {args.idf_file} not exist")
+        if args.codegen_version > __version__ or args.codegen_version <= 0:
+            raise ArgException(f"argument -v/--codegen_version: validate failed, must less than or equal to {__version__} and bigger than 0")
+        self.codegen_version = args.codegen_version
         out_dir = os.path.join(os.getcwd(), args.directory)
         if not intf_file.endswith(".yaml"):
             raise ArgException(f"The IDF file ({intf_file}) not endswith .yaml")
@@ -96,5 +119,5 @@ class CodeGen(object):
         self._gen(intf_file, out_dir)
 
 if __name__ == "__main__":
-    gen = CodeGen(None)
+    gen = CodeGen(sys.argv)
     gen._gen("com.litebmc.test.xml", ".")

{lbkit-0.5.20 → lbkit-0.5.23}/lbkit/codegen/ctype_defination.py

@@ -544,8 +544,8 @@ CTYPE_OBJS = {
     "string": CTypeBase(
         ["<const>gchar *<arg_name>"],
         ["gchar **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_string_encode(<arg_name>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_string_encode(<arg_name>)"],
         ["<arg_in> = g_strdup(g_variant_get_string(<arg_name>, NULL))"],
         StringValidator("^.*$"),
         ["const gchar *<arg_name>"],
@@ -555,8 +555,8 @@ CTYPE_OBJS = {
     "object_path": CTypeBase(
         ["<const>gchar *<arg_name>"],
         ["gchar **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_object_path_encode(<arg_name>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_object_path_encode(<arg_name>)"],
         ["<arg_in> = g_strdup(g_variant_get_string(<arg_name>, NULL))"],
         StringValidator("^(/[A-Z0-9a-z_]+)*$"),
         ["const gchar *<arg_name>"],
@@ -566,8 +566,8 @@ CTYPE_OBJS = {
     "signature": CTypeBase(
         ["<const>gchar *<arg_name>"],
         ["gchar **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_signature_encode(<arg_name>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_signature_encode(<arg_name>)"],
         ["<arg_in> = g_strdup(g_variant_get_string(<arg_name>, NULL))"],
         StringValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$"),
         ["const gchar *<arg_name>"],
@@ -577,7 +577,7 @@ CTYPE_OBJS = {
     "variant": CTypeBase(
         ["GVariant *<arg_name>"],
         ["GVariant **<arg_name>"],
-        ["gcl_unref_p((GVariant **)&<arg_name>)"],
+        ["lb_unref_p((GVariant **)&<arg_name>)"],
         ["g_variant_take_ref(<arg_name>)", "<arg_out> = g_variant_new_variant(<arg_name>)"],
         ["<arg_in> = g_variant_get_variant(<arg_name>)"],
         IdfValidator()
@@ -585,121 +585,121 @@ CTYPE_OBJS = {
     "array[boolean]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gboolean *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gboolean **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_boolean_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_boolean_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_boolean_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_boolean_decode(<arg_name>, &n_<arg_in>)"],
         BoolArrayValidator()
     ),
     "array[byte]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint8 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"guint8 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_byte_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_byte_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_byte_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_byte_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0xff, 0)
     ),
     "array[int16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint16 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gint16 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_int16_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_int16_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_int16_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_int16_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0x7fff, -(0x8000), True)
     ),
     "array[uint16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint16 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"guint16 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_uint16_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_uint16_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_uint16_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_uint16_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0xffff, 0)
     ),
     "array[int32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint32 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gint32 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_int32_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_int32_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_int32_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_int32_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0x7fff_ffff, -(0x80000000), True)
     ),
     "array[uint32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint32 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"guint32 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_uint32_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_uint32_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_uint32_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_uint32_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0xffff_ffff, 0)
     ),
     "array[int64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint64 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gint64 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_int64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_int64_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_int64_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_int64_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[uint64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint64 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"guint64 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_uint64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_uint64_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
     ),
     "array[ssize]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gssize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gssize **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_int64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_int64_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_int64_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_int64_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gsize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gsize **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_uint64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_uint64_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gdouble **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_double_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_double_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_double_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_double_decode(<arg_name>, &n_<arg_in>)"],
         FloatArrayValidator()
     ),
     "array[unixfd]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint32 *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gint32 **<arg_name>"],
-        ["gcl_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = gcl_array_handle_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = gcl_array_handle_decode(<arg_name>, &n_<arg_in>)"],
+        ["lb_free_p((void **)&<arg_name>)"],
+        ["<arg_out> = lb_array_handle_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_handle_decode(<arg_name>, &n_<arg_in>)"],
         IntegerArrayValidator(0x7fff_ffff_ffff_ffff, 0, True)
     ),
     "array[string]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
         ["gchar ***<arg_name>"],
-        ["gcl_strfreev_p(&<arg_name>)"],
-        ["<arg_out> = gcl_array_string_encode(<arg_name>)"],
-        ["<arg_in> = gcl_array_string_decode(<arg_name>)"],
+        ["lb_strfreev_p(&<arg_name>)"],
+        ["<arg_out> = lb_array_string_encode(<arg_name>)"],
+        ["<arg_in> = lb_array_string_decode(<arg_name>)"],
         StringArrayValidator("^.*$")
     ),
     "array[object_path]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
         ["gchar ***<arg_name>"],
-        ["gcl_strfreev_p(&<arg_name>)"],
-        ["<arg_out> = gcl_array_object_path_encode(<arg_name>)"],
-        ["<arg_in> = gcl_array_object_path_decode(<arg_name>)"],
+        ["lb_strfreev_p(&<arg_name>)"],
+        ["<arg_out> = lb_array_object_path_encode(<arg_name>)"],
+        ["<arg_in> = lb_array_object_path_decode(<arg_name>)"],
         StringArrayValidator("^(/[A-Z0-9a-z_]+)*$")
     ),
     "array[signature]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
         ["gchar ***<arg_name>"],
-        ["gcl_strfreev_p(&<arg_name>)"],
-        ["<arg_out> = gcl_array_signature_encode(<arg_name>)"],
-        ["<arg_in> = gcl_array_signature_decode(<arg_name>)"],
+        ["lb_strfreev_p(&<arg_name>)"],
+        ["<arg_out> = lb_array_signature_encode(<arg_name>)"],
+        ["<arg_in> = lb_array_signature_decode(<arg_name>)"],
         StringArrayValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$")
     )
 }

{lbkit-0.5.20 → lbkit-0.5.23}/lbkit/codegen/idf_interface.py

@@ -366,7 +366,7 @@ class IdfCtypeRender():
         _, stru_name = get_intfname_and_ctype(match.group(2))
         if match.group(1) == "enum":
             if is_array:
-                return [f"gcl_free_p((void **)&<arg_name>)"]
+                return [f"lb_free_p((void **)&<arg_name>)"]
             return []
         else:
             if is_array:
@@ -587,17 +587,17 @@ class IdfProperty(IdfCtypeRender):
 
         c_flags = []
         if self.private:
-            c_flags.append("PM_FLAGS_PROPERTY_PRIVATE")
+            c_flags.append("LB_FLAGS_PROPERTY_PRIVATE")
         elif "const" in flags:
-            c_flags.append("PM_FLAGS_PROPERTY_EMIT_CONST")
+            c_flags.append("LB_FLAGS_PROPERTY_EMIT_CONST")
         elif "emits_false" in flags:
-            c_flags.append("PM_FLAGS_PROPERTY_EMIT_FALSE")
+            c_flags.append("LB_FLAGS_PROPERTY_EMIT_FALSE")
         elif "emits_invalidation" in flags:
-            c_flags.append("PM_FLAGS_PROPERTY_EMIT_INVALIDATES")
+            c_flags.append("LB_FLAGS_PROPERTY_EMIT_INVALIDATES")
         else:
-            c_flags.append("PM_FLAGS_PROPERTY_EMIT_TRUE")
+            c_flags.append("LB_FLAGS_PROPERTY_EMIT_TRUE")
         if self.deprecated:
-            c_flags.append("PM_FLAGS_PROPERTY_DEPRECATED")
+            c_flags.append("LB_FLAGS_PROPERTY_DEPRECATED")
         if len(c_flags) == 0:
             self.desc_flags = "0"
         else:
@@ -1102,9 +1102,8 @@ class IdfInterface(IdfInterfaceBase):
         intf_stru = IdfStructure(self, idf, propety_key="properties")
         self.structures[self.alias] = intf_stru
 
-    def render_dbus_xml(self, template, out_file):
-
-        out = self.render(self.lookup, template, intf=self)
+    def render_dbus_xml(self, template, out_file, codegen_version):
+        out = self.render(self.lookup, template, intf=self, codegen_version=codegen_version)
         hash = hashlib.sha256()
         hash.update(out.encode('utf-8'))
         self.introspect_xml_sha256 = hash.hexdigest()
@@ -1112,8 +1111,8 @@ class IdfInterface(IdfInterfaceBase):
         with open(out_file, "w") as fd:
             fd.write(out)
 
-    def render_c_source(self, template, out_file):
+    def render_c_source(self, template, out_file, codegen_version):
 
-        out = self.render(self.lookup, template, intf=self)
+        out = self.render(self.lookup, template, intf=self, codegen_version=codegen_version)
         with open(out_file, "w") as fd:
             fd.write(out)