lbkit 0.5.21__tar.gz → 0.6.0__tar.gz

{lbkit-0.5.21/lbkit.egg-info → lbkit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.21
+Version: 0.6.0
 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.6.0/lbkit/__init__.py

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

lbkit-0.6.0/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.21 → lbkit-0.6.0}/lbkit/cli.py

@@ -224,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.21 → lbkit-0.6.0}/lbkit/codegen/codegen.py

@@ -67,8 +67,8 @@ class CodeGen(object):
         # 默认的自动生成工具版本号为2
         parser.add_argument("-cv", "--codegen_version", help=f'''must less than or equal to {__version__}, default: 2
                             description of changes:
-                            3: compatible with libgcom/0.7.x
-                            2: compatible with libgcom/0.6.x
+                            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=".")
@@ -83,7 +83,7 @@ class CodeGen(object):
             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，该版本配套libgcom/0.6.0版本，其GclProperty无set/get成员
+            # 为保障兼容，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")

{lbkit-0.5.21 → lbkit-0.6.0}/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.21 → lbkit-0.6.0}/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:

{lbkit-0.5.21 → lbkit-0.6.0}/lbkit/codegen/template/client.c.mako

@@ -1,4 +1,4 @@
-#include "gcl_base.h"
+#include "lb_base.h"
 #include "${intf.name}.h"
 
 <% class_name = intf.alias + "_Cli"
@@ -25,7 +25,7 @@ gint ${class_name}_set_${prop.name}(const ${class_name} *object,
     % for line in prop.encode_func():
     ${line.replace("<arg_out>", "tmp").replace("n_<arg_name>", "n_" + prop.name).replace("<arg_name>", prop.name)};
     % endfor
-    return gcl_impl.write_property((GclObject *)object, &${properties}.${prop.name}, tmp, error);
+    return lb_impl.write_property((LBO *)object, &${properties}.${prop.name}, tmp, error);
 }
 
 % endif
@@ -52,7 +52,7 @@ gint ${class_name}_get_${prop.name}(const ${class_name} *object, ${", ".join(pro
     % endfor
     GVariant *out = NULL;
 
-    gint ret = gcl_impl.read_property((GclObject *)object, &${properties}.${prop.name}, &out, error);
+    gint ret = lb_impl.read_property((LBO *)object, &${properties}.${prop.name}, &out, error);
     if (ret == 0 && out) {
     % for line in prop.decode_func():
         ${line.replace("<arg_in>", "tmp_value").replace("<arg_name>", "out")};
@@ -98,32 +98,32 @@ int ${class_name}_Call_${method.name}(const ${class_name} *object,
     % if len(method.parameters.parameters) == 0:
     void *req = NULL;
     % endif
-    return gcl_impl.call_method((GclObject *)object, (const GclMethod *)&${method_processer}->${method.name},
+    return lb_impl.call_method((LBO *)object, (const LBMethod *)&${method_processer}->${method.name},
                                  (void *)req, (void **)rsp, timeout, error);
 }
 
 % endfor
-static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
-static void _${class_name}_destroy(GclObject *obj);
+static LBO *_${class_name}_create(const gchar *obj_name, gpointer opaque);
+static void _${class_name}_destroy(LBO *obj);
 
-static GclInterface _${class_name}_interface = {
+static LBInterface _${class_name}_interface = {
     .create = _${class_name}_create,
     .destroy = _${class_name}_destroy,
     .is_remote = 1,
     .name = "${intf.name}",
-    .properties = (GclProperty *)&${properties},
-    .interface = NULL, /* load from usr/share/dbus-1/interfaces/${intf.name}.xml by gcl_init */
+    .properties = (LBProperty *)&${properties},
+    .interface = NULL, /* load from usr/share/dbus-1/interfaces/${intf.name}.xml by lb_init */
 };
 
 /**
  * @brief 销毁对象
  *
- * @param gcl_obj 待销毁的对象句柄
+ * @param lb_obj 待销毁的对象句柄
  */
-static void _${class_name}_destroy(GclObject *gcl_obj)
+static void _${class_name}_destroy(LBO *lb_obj)
 {
-    g_assert(gcl_obj);
-    ${class_name} *obj = (${class_name} *)gcl_obj;
+    g_assert(lb_obj);
+    ${class_name} *obj = (${class_name} *)lb_obj;
     g_rec_mutex_clear(obj->_base.lock);
     g_free(obj->_base.lock);
     ${intf.alias}_clean(obj);
@@ -136,16 +136,16 @@ static void _${class_name}_destroy(GclObject *gcl_obj)
  * @param obj_name 对象名，需要由调用者分配内存
  * @param opaque 上层应用需要写入对象的用户数据，由上层应用使用
  */
-static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
+static LBO *_${class_name}_create(const gchar *obj_name, gpointer opaque)
 {
     ${class_name} *obj = g_new0(${class_name}, 1);
-    memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);
+    memcpy(obj->_base.magic, LB_MAGIC, strlen(LB_MAGIC) + 1);
     obj->_base.lock = g_new0(GRecMutex, 1);
     g_rec_mutex_init(obj->_base.lock);
     obj->_base.name = obj_name;
     obj->_base.intf = &_${class_name}_interface;
     obj->_base.opaque = opaque;
-    return (GclObject *)obj;
+    return (LBO *)obj;
 }
 
 % for signal in intf.signals:
@@ -157,9 +157,9 @@ guint ${class_name}_Subscribe_${signal.name}(${class_name}_${signal.name}_Signal
     const gchar *bus_name, const gchar *object_path, const gchar *arg0, gpointer user_data)
 % endif
 {
-    return gcl_impl.subscribe_signal(&_${class_name}_interface, bus_name,
-        (const GclSignal *)&${signal_processer}->${signal.name},
-        object_path, arg0, (gcl_signal_handler)handler, user_data);
+    return lb_impl.subscribe_signal(&_${class_name}_interface, bus_name,
+        (const LBSignal *)&${signal_processer}->${signal.name},
+        object_path, arg0, (lbo_signal_handler)handler, user_data);
 }
 
 % if signal.deprecated:
@@ -168,11 +168,11 @@ __attribute__((__deprecated__)) void ${class_name}_Unsubscribe_${signal.name}(gu
 void ${class_name}_Unsubscribe_${signal.name}(guint *id)
 % endif
 {
-    return gcl_impl.unsubscribe_signal(id);
+    return lb_impl.unsubscribe_signal(id);
 }
 
 % endfor
-GclInterface *${class_name}_interface(void)
+LBInterface *${class_name}_interface(void)
 {
     return &_${class_name}_interface;
 }
@@ -188,13 +188,13 @@ static void __attribute__((constructor(150))) ${class_name}_register(void)
     ${signal_processer} = ${intf.alias}_signals();
 
     // 从公共库中复制方法处理函数
-    _${class_name}_interface.methods = (GclMethod *)${intf.alias}_methods();
-    _${class_name}_interface.signals = (GclSignal *)${intf.alias}_signals();
+    _${class_name}_interface.methods = (LBMethod *)${intf.alias}_methods();
+    _${class_name}_interface.signals = (LBSignal *)${intf.alias}_signals();
     ${method_processer} = ${intf.alias}_methods();
 
     // 从公共库中复制属性信息
     memcpy(&${properties}, ${intf.alias}_properties_const(), sizeof(${properties}));
-    gcl_interface_register(&_${class_name}_interface,
+    lb_interface_register(&_${class_name}_interface,
                            "${intf.introspect_xml_sha256}",
                            "/usr/share/dbus-1/interfaces/${intf.name}.xml");
 }

{lbkit-0.5.21 → lbkit-0.6.0}/lbkit/codegen/template/client.h.mako

@@ -3,7 +3,7 @@
 
 #include <glib-2.0/glib.h>
 #include <glib-2.0/gio/gio.h>
-#include "gcl_base.h"
+#include "lb_base.h"
 #include "public/${intf.name}.h"
 
 #ifdef __cplusplus
@@ -110,7 +110,7 @@ void ${class_name}_Unsubscribe_${signal.name}(guint *id);
 % endfor
 
 ${class_name}_Properties *${class_name}_properties(void);
-GclInterface *${class_name}_interface(void);
+LBInterface *${class_name}_interface(void);
 #define ${class_name.upper()}_INTERFACE ${class_name}_interface()
 
 #ifdef __cplusplus