openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/c/argument.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+from xml.dom import Node
+from bmcgo.codegen.c.comment import Comment
+from bmcgo.codegen.c.ctype_defination import CTypes
+from bmcgo.codegen.c.helper import Helper
+from bmcgo.logger import Logger
+
+log = Logger("c_argument")
+
+
+
+class Argument():
+    def __init__(self, node: Node, comment: Comment, prefix: str = ""):
+        self.node = node
+        prefix = prefix + "    "
+        self.comment = comment or Comment()
+        self.name = Helper.get_node_value(node, "name", "")
+        self.direction = Helper.get_node_value(node, "direction", "in")
+        self.signature = Helper.get_node_value(node, "type")
+        if self.signature is None:
+            log.error("参数缺少 'type' 属性")
+        self.ctype = CTypes.types.get(self.signature, CTypes.types.get("*"))
+        if self.ctype is None:
+            log.error("未知的 C 类型: %s", self.signature)
+        if self.direction != "in" and self.direction != "out":
+            log.error("无效的方向参数: '%s', 其值必须为 [in out], 获取到 %s" % {self.name, self.direction})
+        log.debug("%s 参数, 名称: %33s 签名: %4s 方向: %s" % (
+            prefix, self.name + ",", self.signature + ",", self.direction))
+
+    def set_arg_id(self, arg_id: int):
+        if not self.name:
+            self.name = "arg_" + str(arg_id)

bmcgo/codegen/c/codegen.py

@@ -0,0 +1,153 @@
+#!/usr/bin/python3
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import hashlib
+import json
+import os
+import subprocess
+import stat
+from xml.dom import minidom, Node
+import yaml
+import semver
+from mako.lookup import TemplateLookup
+from bmcgo.codegen.c.interface import Interface
+from bmcgo.codegen.c.comment import Comment
+from bmcgo.codegen.c.renderer import Renderer
+from bmcgo.logger import Logger
+cwd = os.path.split(os.path.realpath(__file__))[0]
+
+global log
+log = Logger()
+
+PKG_PUBLIC = "public"
+PKG_SERVER = "server"
+PKG_CLIENT = "client"
+
+
+class XmlInterfaces(Renderer):
+    def __init__(self, lookup, xml_file, base_version):
+        super(Renderer, self).__init__()
+        self.base_version = base_version
+        self.version = "0.0.1"
+        self.name = os.path.basename(xml_file)[:-4]
+        self.lookup = lookup
+        self.introspect_xml_sha256 = None       # 自举文件的sha256值
+        file_handler = open(xml_file)
+        self.dom = minidom.parse(file_handler)
+        file_handler.close()
+        self.interfaces: list[Interface] = []
+        for subnode in self.dom.childNodes:
+            if subnode.nodeType == Node.DOCUMENT_TYPE_NODE:
+                continue
+            if subnode.nodeType == Node.ELEMENT_NODE:
+                self._parse_subnode(subnode)
+
+    def render_xml(self, template, out_file):
+        file_handler = os.fdopen(os.open(out_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                                         stat.S_IWUSR | stat.S_IRUSR), 'w')
+        out = self.render(self.lookup, template, interfaces=self.interfaces, version=self.base_version)
+        hash_val = hashlib.sha256()
+        hash_val.update(out.encode('utf-8'))
+        self.introspect_xml_sha256 = hash_val.hexdigest()
+        log.info("The sha256sum of interface %s is %s", out_file, self.introspect_xml_sha256)
+        file_handler.write(out)
+        file_handler.close()
+
+    def render_c_language(self, template, out_file):
+        file_handler = os.fdopen(os.open(out_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                                         stat.S_IWUSR | stat.S_IRUSR), 'w')
+        out = self.render(self.lookup, template, xml=self, version=self.base_version)
+        file_handler.write(out)
+        file_handler.close()
+
+    def _parse_subnode(self, subnode):
+        remove_node = []
+        comment = Comment()
+        for child in subnode.childNodes:
+            if child.nodeType == Node.COMMENT_NODE:
+                comment.append(child)
+            elif child.nodeType != Node.ELEMENT_NODE:
+                continue
+            if child.nodeName == "version":
+                self.version = str(child.firstChild.nodeValue)
+                ver = semver.parse(self.version, False)
+                if ver is None:
+                    raise Exception("Interface has version error, abort")
+                for com in comment.nodes:
+                    subnode.removeChild(com)
+                remove_node.append(child)
+            elif child.nodeName == "interface":
+                intf = Interface(child, comment, self.version)
+                self.interfaces.append(intf)
+            comment = Comment()
+        for node in remove_node:
+            subnode.removeChild(node)
+
+
+class CodeGen(object):
+    def __init__(self, base_version):
+        self.base_version = base_version
+
+    def format(self, out_file):
+        try:
+            subprocess.run(["/usr/bin/clang-format", "--version"], stderr=subprocess.DEVNULL,
+                           stdout=subprocess.DEVNULL)
+        except Exception:
+            log.error("Command clang-format not found, skip format %s/%s", os.getcwd(), out_file)
+            return
+        if not os.path.isfile(".clang-format"):
+            log.error("the style file .clang-format is missing, skip format %s/%s", os.getcwd(), out_file)
+            return
+        subprocess.run(["/usr/bin/clang-format", "--style=file", "-i", out_file])
+
+    def gen(self, xml_file, directory="."):
+        os.makedirs(os.path.join(directory, PKG_PUBLIC), exist_ok=True)
+        os.makedirs(os.path.join(directory, PKG_SERVER), exist_ok=True)
+        os.makedirs(os.path.join(directory, PKG_CLIENT), exist_ok=True)
+        lookup = TemplateLookup(directories=os.path.join(cwd, "template"))
+        interfaces = XmlInterfaces(lookup, xml_file, self.base_version)
+        out_file = os.path.join(directory, PKG_PUBLIC, os.path.basename(xml_file))
+        interfaces.render_xml("interface.introspect.xml.mako", out_file)
+        for code_type in [PKG_SERVER, PKG_CLIENT, PKG_PUBLIC]:
+            out_file = os.path.join(directory, code_type, interfaces.name + ".h")
+            interfaces.render_c_language(code_type + ".h.mako", out_file)
+            self.format(out_file)
+            out_file = os.path.join(directory, code_type, interfaces.name + ".c")
+            interfaces.render_c_language(code_type + ".c.mako", out_file)
+            self.format(out_file)
+        json_file = os.path.join(directory, "package.yml")
+        data = {
+            "version": interfaces.version,
+            "name": interfaces.name
+        }
+        with os.fdopen(os.open(json_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                               stat.S_IWUSR | stat.S_IRUSR), 'w') as file_handler:
+            yaml.dump(data, file_handler, encoding='utf-8', allow_unicode=True)
+        log.success("Generate code successfully, interface: %s", xml_file)
+
+    def gen_mds(self, mds):
+        file_handler = open(mds, "r")
+        mds = json.load(file_handler)
+        service_type = mds.get("type", [])
+        if "application" not in service_type:
+            return
+        file_handler.close()
+        service_name = mds.get("name", "")
+        if service_name in ["ssdp", "libproto-mc4c", "file_transfer"]:
+            return
+        lookup = TemplateLookup(directories=os.path.join(cwd, "template"))
+        template = lookup.get_template("micro_component.c.mako")
+        out = template.render(lookup=lookup, mds=mds, version=self.base_version)
+        os.makedirs("service", exist_ok=True)
+        file_handler = os.fdopen(os.open("service/micro_component.c", os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                                         stat.S_IWUSR | stat.S_IRUSR), 'w')
+        file_handler.write(out)
+        file_handler.close()

bmcgo/codegen/c/comment.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python3
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+from xml.dom import Node
+
+
+class Comment():
+    def __init__(self):
+        self.texts: list[str] = []
+        self.nodes: list[Node] = []
+
+    def append(self, node: Node):
+        self.texts.append(node.nodeValue.strip())
+        self.nodes.append(node)

bmcgo/codegen/c/ctype_defination.py

@@ -0,0 +1,353 @@
+#!/usr/bin/python3
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+
+class CTypeBase(object):
+    arg_in: str     # 做为函数的入参参数
+    arg_out: str    # 做为函数的出差参数
+    write_type: str  # 属性写函数关键字，前加mdb_set_xxx得到真实函数名
+    variant_type: str  # 属性的gvariant type(signature)字符串
+
+    def __init__(self, variant_type, write_type, arg_in, arg_out, arg_decode,
+                 arg_encode,
+                 args_write_remote_declear, arg_free):
+        self.variant_type = variant_type
+        self.write_type = write_type
+        self.arg_in = arg_in
+        self.arg_out = arg_out
+        self.arg_decode = arg_decode
+        self.arg_encode = arg_encode
+        self.arg_free = arg_free
+        self.args_write_remote_declear = args_write_remote_declear
+        pass
+
+    def render_in_args(self, prop_name: str, is_const: bool):
+        return self._replace(self.arg_in, prop_name, is_const)
+
+    def render_out_args(self, prop_name, is_const: bool):
+        return self._replace(self.arg_out, prop_name, is_const)
+
+    def render_in_encode(self, prop_name):
+        pass
+
+    def render_out_decode(self, prop_name):
+        pass
+
+    def is_array(self):
+        glib_type = ["b", "y", "n", "q", "i", "u", "x", "t", "d", "h", "s", "o", "g"]
+        if self.variant_type.startswith("a") and self.variant_type[1:] in glib_type:
+            return True
+        else:
+            return False
+
+    def _replace(self, template: str, prop_name: str, is_const: bool):
+        out = template.replace("<arg_name>", prop_name)
+        const_str = ""
+        if is_const:
+            const_str = "const "
+        return out.replace("<const>", const_str)
+
+
+class CTypes():
+    types = {
+        "b": CTypeBase(variant_type="b",
+                       write_type="boolean",
+                       arg_in="gboolean <arg_name>",
+                       arg_out="gboolean *<arg_name>",
+                       args_write_remote_declear="g_variant_new_boolean(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_boolean(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_boolean(<req><arg_name>));"],),
+        "ab": CTypeBase(variant_type="ab",
+                        write_type="array_boolean",
+                        arg_in="gsize n_<arg_name>, <const>gboolean *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gboolean **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"b\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, " +
+                                    "<req><arg_name>, boolean, \"b\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"b\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "y": CTypeBase(variant_type="y",
+                       write_type="uint8",
+                       arg_in="guint8 <arg_name>",
+                       arg_out="guint8 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_byte(<arg_name>)",
+                       arg_decode=["<req><arg_name> = parameter_get_uint8(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_byte(<req><arg_name>));"]),
+        "ay": CTypeBase(variant_type="ay",
+                        write_type="array_uint8",
+                        arg_in="gsize n_<arg_name>, <const>guint8 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, guint8 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"y\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " uint8, \"y\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"y\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "n": CTypeBase(variant_type="n",
+                       write_type="int16",
+                       arg_in="gint16 <arg_name>",
+                       arg_out="gint16 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_int16(<arg_name>)",
+                       arg_decode=["<req><arg_name> = parameter_get_int16(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_int16(<req><arg_name>));"]),
+        "an": CTypeBase(variant_type="an",
+                        write_type="array_int16",
+                        arg_in="gsize n_<arg_name>, <const>gint16 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gint16 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"n\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " int16, \"n\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"n\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "q": CTypeBase(variant_type="q",
+                       write_type="uint16",
+                       arg_in="guint16 <arg_name>",
+                       arg_out="guint16 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_uint16(<arg_name>)",
+                       arg_decode=["<req><arg_name> = parameter_get_uint16(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_uint16(<req><arg_name>));"]),
+        "aq": CTypeBase(variant_type="aq",
+                        write_type="array_uint16",
+                        arg_in="gsize n_<arg_name>, <const>guint16 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, guint16 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"q\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " uint16, \"q\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"q\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "i": CTypeBase(variant_type="i",
+                       write_type="int32",
+                       arg_in="gint32 <arg_name>",
+                       arg_out="gint32 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_int32(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_int32(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_int32(<req><arg_name>));"]),
+        "ai": CTypeBase(variant_type="ai",
+                        write_type="array_int32",
+                        arg_in="gsize n_<arg_name>, <const>gint32 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gint32 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"i\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " int32, \"i\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"i\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "u": CTypeBase(variant_type="u",
+                       write_type="uint32",
+                       arg_in="guint32 <arg_name>",
+                       arg_out="guint32 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_uint32(<arg_name>)",
+                       arg_decode=["<req><arg_name> = parameter_get_uint32(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_uint32(<req><arg_name>));"]),
+        "au": CTypeBase(variant_type="au",
+                        write_type="array_uint32",
+                        arg_in="gsize n_<arg_name>, <const>guint32 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, guint32 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"u\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " uint32, \"u\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"u\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "x": CTypeBase(variant_type="x",
+                       write_type="int64",
+                       arg_in="gint64 <arg_name>",
+                       arg_out="gint64 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_int64(<arg_name>)",
+                       arg_decode=["<req><arg_name> = parameter_get_int64(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_int64(<req><arg_name>));"]),
+        "ax": CTypeBase(variant_type="ax",
+                        write_type="array_int64",
+                        arg_in="gsize n_<arg_name>, <const>gint64 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gint64 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"x\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " int64, \"x\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"x\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "t": CTypeBase(variant_type="t",
+                       write_type="uint64",
+                       arg_in="guint64 <arg_name>",
+                       arg_out="guint64 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_uint64(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_uint64(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_uint64(<req><arg_name>));"]),
+        "at": CTypeBase(variant_type="at",
+                        write_type="array_uint64",
+                        arg_in="gsize n_<arg_name>, <const>guint64 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, guint64 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"t\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " uint64, \"t\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"t\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "d": CTypeBase(variant_type="d",
+                       write_type="double",
+                       arg_in="gdouble <arg_name>",
+                       arg_out="gdouble *<arg_name>",
+                       args_write_remote_declear="g_variant_new_double(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_double(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_double(<req><arg_name>));"]),
+        "ad": CTypeBase(variant_type="ad",
+                        write_type="array_double",
+                        arg_in="gsize n_<arg_name>, <const>gdouble *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gdouble **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"d\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " double, \"d\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"d\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "h": CTypeBase(variant_type="h",
+                       write_type="handle",
+                       arg_in="gint32 <arg_name>",
+                       arg_out="gint32 *<arg_name>",
+                       args_write_remote_declear="g_variant_new_handle(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_handle(parameters, arg_id);"],
+                       arg_free=[],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_handle(<req><arg_name>));"]),
+        "ah": CTypeBase(variant_type="ah",
+                        write_type="array_handle",
+                        arg_in="gsize n_<arg_name>, <const>gint32 *<arg_name>",
+                        arg_out="gsize *n_<arg_name>, gint32 **<arg_name>",
+                        args_write_remote_declear="BUILD_BASIC_TYPE_ARRAY(\"h\", n_<arg_name>, <arg_name>)",
+                        arg_decode=["ITER_BASIC_TYPE_ARRAY(parameters, arg_id, <req>n_<arg_name>, <req><arg_name>," +
+                                    " int32, \"h\");"],
+                        arg_free=["g_free(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_BASIC_TYPE_ARRAY(\"h\", <req>n_<arg_name>, <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "s": CTypeBase(variant_type="s",
+                       write_type="string",
+                       arg_in="<const>gchar *<arg_name>",
+                       arg_out="gchar **<arg_name>",
+                       args_write_remote_declear="g_variant_new_string(<arg_name> ? <arg_name> : \"\")",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_string(parameters, arg_id);"],
+                       arg_free=["g_free(<req><arg_name>);"],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_string(<req><arg_name>));"]),
+        "as": CTypeBase(variant_type="as",
+                        write_type="array_string",
+                        arg_in="<const>gchar *<const>*<arg_name>",
+                        arg_out="gchar ***<arg_name>",
+                        args_write_remote_declear="BUILD_STRING_TYPE_ARRAY(\"s\", <arg_name>)",
+                        arg_decode=["ITER_STRING_TYPE_ARRAY(parameters, arg_id, <req><arg_name>, char *, \"s\");"],
+                        arg_free=["g_strfreev(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_STRING_TYPE_ARRAY(\"s\", <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "g": CTypeBase(variant_type="g",
+                       write_type="signature",
+                       arg_in="<const>gchar *<arg_name>",
+                       arg_out="gchar **<arg_name>",
+                       args_write_remote_declear="g_variant_new_signature(<arg_name> ? <arg_name> : \"\")",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_signature(parameters, arg_id);"],
+                       arg_free=["g_free(<req><arg_name>);"],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_signature(<req><arg_name>));"]),
+        "ag": CTypeBase(variant_type="ag",
+                        write_type="array_signature",
+                        arg_in="<const>gchar *<const>*<arg_name>",
+                        arg_out="gchar ***<arg_name>",
+                        args_write_remote_declear="BUILD_STRING_TYPE_ARRAY(\"g\", <arg_name>)",
+                        arg_decode=["ITER_STRING_TYPE_ARRAY(parameters, arg_id, <req><arg_name>, char *, \"g\");"],
+                        arg_free=["g_strfreev(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_STRING_TYPE_ARRAY(\"g\", <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "o": CTypeBase(variant_type="o",
+                       write_type="object_path",
+                       arg_in="<const>gchar *<arg_name>",
+                       arg_out="gchar **<arg_name>",
+                       args_write_remote_declear="g_variant_new_object_path(<arg_name> ? <arg_name> : \"\")",
+                       arg_decode=[
+                           "<req><arg_name> = parameter_get_object_path(parameters, arg_id);"],
+                       arg_free=["g_free(<req><arg_name>);"],
+                       arg_encode=[
+                           "g_variant_builder_add_value(&builder, g_variant_new_object_path(<req><arg_name>));"]),
+        "ao": CTypeBase(variant_type="ao",
+                        write_type="array_object_path",
+                        arg_in="<const>gchar *<const>*<arg_name>",
+                        arg_out="gchar ***<arg_name>",
+                        args_write_remote_declear="BUILD_STRING_TYPE_ARRAY(\"o\", <arg_name>)",
+                        arg_decode=[
+                            "ITER_STRING_TYPE_ARRAY(parameters, arg_id, <req><arg_name>, char *, \"o\");"],
+                        arg_free=["g_strfreev(<req><arg_name>);"],
+                        arg_encode=[
+                            "tmp_v = BUILD_STRING_TYPE_ARRAY(\"o\", <req><arg_name>);",
+                            "g_variant_builder_add_value(&builder, tmp_v);"],
+                        ),
+        "*": CTypeBase(variant_type="v",
+                       write_type="variant",
+                       arg_in="GVariant *<arg_name>",
+                       arg_out="GVariant **<arg_name>",
+                       args_write_remote_declear="g_variant_ref(<arg_name>)",
+                       arg_decode=[
+                           "<req><arg_name> = g_variant_get_child_value(parameters, arg_id);"],
+                       arg_free=["if (<req><arg_name>) {",
+                                 "    g_variant_unref(<req><arg_name>);", "}"],
+                       arg_encode=[
+                           "g_variant_take_ref(<req><arg_name>);",
+                           "g_variant_builder_add_value(&builder, <req><arg_name>);"])
+    }

bmcgo/codegen/c/helper.py

@@ -0,0 +1,87 @@
+#!/usr/bin/python3
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import subprocess
+import sys
+import os
+from xml.dom import minidom, Node
+from colorama import Fore, Style
+from bmcgo.logger import Logger
+
+global log
+log = Logger()
+
+
+class Helper():
+    @staticmethod
+    def get_node_value(dom: Node, name, default=None):
+        node: minidom.Attr = dom.attributes.get(name)
+        if node is None:
+            if default is None:
+                raise Exception("节点分析失败, 终止构建")
+            return default
+        return node.childNodes[0].nodeValue.strip()
+
+    @staticmethod
+    def get_git_path():
+        if os.path.isfile("/usr/bin/git"):
+            return "/usr/bin/git"
+        elif os.path.isfile("/usr/local/bin/git"):
+            return "/usr/local/bin/git"
+        elif os.path.isfile("/usr/sbin/git"):
+            return "/usr/sbin/git"
+        else:
+            raise OSError("git 命令未找到, 请检查 git 是否安装或是否安装到系统路径")
+
+    @staticmethod
+    def get_privilege(value):
+        splits = value.split(",", -1)
+        privilege = []
+        for split in splits:
+            split = split.strip()
+            if split == "UserMgmt":
+                privilege.append("PRI_USER_MGMT")
+            elif split == "BasicSetting":
+                privilege.append("PRI_BASIC_SETTING")
+            elif split == "KVMMgmt":
+                privilege.append("PRI_KVM_MGMT")
+            elif split == "VMMMgmt":
+                privilege.append("PRI_VMM_MGMT")
+            elif split == "SecurityMgmt":
+                privilege.append("PRI_SECURITY_MGMT")
+            elif split == "PowerMgmt":
+                privilege.append("PRI_POWER_MGMT")
+            elif split == "DiagnoseMgmt":
+                privilege.append("PRI_DIAGNOSE_MGMT")
+            elif split == "ReadOnly":
+                privilege.append("PRI_READ_ONLY")
+            elif split == "ConfigureSelf":
+                privilege.append("PRI_CONFIG_SELF")
+        if len(privilege) == 0:
+            return "0"
+        return " | ".join(privilege)
+
+    @staticmethod
+    def run(cmd, check=True, stderr=sys.stderr, stdout=sys.stdout):
+        log.info("开始运行命令: %s %s %s", Fore.GREEN,
+                     " ".join(cmd), Style.RESET_ALL)
+        ret = subprocess.run(cmd, check=check, stderr=stderr, stdout=stdout)
+        return ret.returncode
+
+    @staticmethod
+    def string_to_bool(str_value):
+        if str_value.lower() == "false":
+            return False
+        if str_value == "":
+            return False
+        if str_value == "0":
+            return False
+        return True