lbkit 0.5.6__tar.gz → 0.5.8__tar.gz

{lbkit-0.5.6/lbkit.egg-info → lbkit-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.6
+Version: 0.5.8
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.8/lbkit/__init__.py

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

{lbkit-0.5.6 → lbkit-0.5.8}/lbkit/codegen/ctype_defination.py

@@ -1,14 +1,30 @@
 """语言相关类型定义"""
 import sys
+from lbkit.errors import OdfValidateException
 
 
 class IdfValidator():
-    def odf_schema(self, allow_ref, idf_validator):
+    validator = {}
+
+    def set_validator(self, value):
+        self.validator = value
+
+    def odf_validate(self):
+        idf_validator = idf_validator
+        return []
+
+    def odf_schema(self, allow_ref):
+        allow_ref = allow_ref
+        idf_validator = idf_validator
         return None
 
 
 class BoolValidator(IdfValidator):
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_boolean(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             return {
                 "anyOf": [
@@ -27,8 +43,12 @@ class BoolValidator(IdfValidator):
 
 
 class BoolArrayValidator(BoolValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = ["validate_odf_as_boolean_v(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -54,29 +74,57 @@ class IntegerValidator(IdfValidator):
     maximum = sys.maxsize * 2
     minimum = -(sys.maxsize + 1) * 2
 
-    def __init__(self, max, min):
+    def __init__(self, max, min, signed=False):
         self.maximum = max
         self.minimum = min
+        self.signed = signed
+        if not self.signed and self.minimum < 0:
+            self.minimum = 0
+        if self.maximum < self.minimum:
+            raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}")
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
-        """
-            返回整数类型成员的ODF schema
-            idf_validator为IDF模型中加载的数据验证器的对象
-        """
-        max = idf_validator.get("max", self.maximum)
+    def set_validator(self, value):
+        super().set_validator(value)
+        max = self.validator.get("max", self.maximum)
         if max > self.maximum:
             max = self.maximum
-        min = idf_validator.get("min", self.minimum)
+        min = self.validator.get("min", self.minimum)
         if min < self.minimum:
             min = self.minimum
+        self.maximum = max
+        self.minimum = min
+        if not self.signed and self.minimum < 0:
+            self.minimum = 0
+        if self.maximum < self.minimum:
+            raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}")
+
+    def odf_validate(self):
+        func = []
+        if self.signed:
+            if self.minimum == -9223372036854775808:
+                func.append(f"validate_odf_as_signed(doc, node, prop, {self.maximum}, G_MININT64, error_list)")
+            else:
+                func.append(f"validate_odf_as_signed(doc, node, prop, {self.maximum}, {self.minimum}, error_list)")
+        else:
+            if self.maximum == 18446744073709551615:
+                func.append(f"validate_odf_as_unsigned(doc, node, prop, G_MAXUINT64, {self.minimum}, error_list)")
+            else:
+                func.append(f"validate_odf_as_unsigned(doc, node, prop, {self.maximum}, {self.minimum}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        """
+            返回整数类型成员的ODF schema
+            idf_validator为IDF模型中加载的数据验证器的对象
+        """
         if allow_ref:
             return {
                 "anyOf": [
                     {
                         "type": "integer",
-                        "maximum": max,
-                        "minimum": min
+                        "maximum": self.maximum,
+                        "minimum": self.minimum
                     },
                     {
                         "$ref": "#/$defs/ref_value"
@@ -86,14 +134,33 @@ class IntegerValidator(IdfValidator):
         else:
             return {
                 "type": "integer",
-                "maximum": max,
-                "minimum": min
+                "maximum": self.maximum,
+                "minimum": self.minimum
             }
 
 
 class IntegerArrayValidator(IntegerValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = []
+        min = self.minimum
+        max = self.maximum
+        if self.signed:
+            if self.minimum <= -0x8000_0000_0000_0000:
+                min = "G_MININT64"
+            if self.maximum >= 0x7fff_ffff_ffff_ffff:
+                max = "G_MAXINT64"
+        else:
+            if self.maximum >= 0xffff_ffff_ffff_ffff:
+                max = "G_MAXUINT64"
+
+        if self.signed:
+            func.append(f"validate_odf_as_signed_v(doc, node, prop, {max}, {min}, error_list)")
+        else:
+            func.append(f"validate_odf_as_unsigned_v(doc, node, prop, {max}, {min}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -119,35 +186,58 @@ class FloatValidator(IdfValidator):
     maximum = sys.float_info.max
     minimum = -sys.float_info.max
 
+    exclusive_max = None
+    exclusive_min = None
+
     def __init__(self):
+        self.max_key = "maximum"
+        self.max_val = self.maximum
+        self.min_key = "minimum"
+        self.min_val = self.minimum
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_double(doc, node, prop, error_list)"]
+        if self.exclusive_max is not None:
+            func.append(f"validate_odf_as_float_exclusive_max(doc, node, prop, {self.exclusive_max}, error_list)")
+        elif self.maximum != sys.float_info.max:
+            func.append(f"validate_odf_as_float_max(doc, node, prop, {self.maximum}, error_list)")
+
+        if self.exclusive_min is not None:
+            func.append(f"validate_odf_as_float_exclusive_min(doc, node, prop, {self.exclusive_min}, error_list)")
+        elif self.minimum != (-sys.float_info.max):
+            func.append(f"validate_odf_as_float_min(doc, node, prop, {self.minimum}, error_list)")
+        return func
+
+    def set_validator(self, value):
+        super().set_validator(value)
+        self.maximum = self.validator.get("max", self.maximum)
+        self.minimum = self.validator.get("min", self.minimum)
+        self.exclusive_max = self.validator.get("exclusive_max", None)
+        self.exclusive_min = self.validator.get("exclusive_min", None)
+        self.max_key = "maximum"
+        self.min_key = "minimum"
+        self.max_val = self.maximum
+        self.min_val = self.minimum
+        if self.exclusive_max is not None:
+            self.max_key = "exclusiveMaximum"
+            self.max_val = self.exclusive_max
+        if self.exclusive_min is not None:
+            self.max_key = "exclusiveMinimum"
+            self.min_val = self.exclusive_min
+
+    def odf_schema(self, allow_ref):
         """
             返回整数类型成员的ODF schema
             idf_validator为IDF模型中加载的数据验证器的对象
         """
-        max = idf_validator.get("max", self.maximum)
-        min = idf_validator.get("min", self.minimum)
-        exclusive_max = idf_validator.get("exclusive_max", None)
-        exclusive_min = idf_validator.get("exclusive_min", None)
-        max_key = "maximum"
-        max_val = max
-        min_key = "minimum"
-        min_val = min
-        if exclusive_max is not None:
-            max_key = "exclusiveMaximum"
-            max_val = exclusive_max
-        if exclusive_min is not None:
-            max_key = "exclusiveMinimum"
-            min_val = exclusive_min
         if allow_ref:
             return {
                 "anyOf": [
                     {
                         "type": "number",
-                        max_key: max_val,
-                        min_key: min_val
+                        self.max_key: self.max_val,
+                        self.min_key: self.min_val
                     },
                     {
                         "$ref": "#/$defs/ref_value"
@@ -157,14 +247,27 @@ class FloatValidator(IdfValidator):
         else:
             return {
                 "type": "number",
-                max_key: max_val,
-                min_key: min_val
+                self.max_key: self.max_val,
+                self.min_key: self.min_val
             }
 
 
 class FloatArrayValidator(FloatValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = ["validate_odf_as_double_v(doc, node, prop, error_list)"]
+        if self.exclusive_max is not None:
+            func.append(f"validate_odf_as_float_exclusive_max_v(doc, node, prop, {self.exclusive_max}, error_list)")
+        elif self.maximum != sys.float_info.max:
+            func.append(f"validate_odf_as_float_max_v(doc, node, prop, {self.maximum}, error_list)")
+
+        if self.exclusive_min is not None:
+            func.append(f"validate_odf_as_float_exclusive_min_v(doc, node, prop, {self.exclusive_min}, error_list)")
+        elif self.minimum != (-sys.float_info.max):
+            func.append(f"validate_odf_as_float_min_v(doc, node, prop, {self.minimum}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -191,32 +294,54 @@ class StringValidator(IdfValidator):
         self.pattern = pattern
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
-        pattern = idf_validator.get("pattern", self.pattern)
+    def set_validator(self, value):
+        self.pattern = self.validator.get("pattern", self.pattern)
+        super().set_validator(value)
+
+    def odf_validate(self):
+        func = []
+        if self.pattern is not None:
+            func.append(f"validate_odf_as_string(doc, node, prop, \"{self.pattern}\", error_list)")
+        else:
+            pattern = "^()|(((\\\\$)|[^$]).*)$"
+            func.append(f"validate_odf_as_string(doc, node, prop, \"{pattern}\", error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
                     {
-                        "type": "string"
+                        "type": "string",
+                        "pattern": "^()|(((\\\\$)|[^$]).*)$"
                     },
                     {
                         "$ref": "#/$defs/ref_value"
                     }
                 ]
             }
-            if pattern is not None:
-                schema["anyOf"][0]["pattern"] = pattern
+            if self.pattern is not None:
+                schema["anyOf"][0]["pattern"] = self.pattern
         else:
             schema = {
                 "type": "string",
-                "pattern": pattern
+                "pattern": self.pattern
             }
         return schema
 
 
 class StringArrayValidator(StringValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = []
+        if self.pattern is not None:
+            func.append(f"validate_odf_as_string_v(doc, node, prop, \"{self.pattern}\", error_list)")
+        else:
+            pattern = "^()|(((\\\\$)|[^$]).*)$"
+            func.append(f"validate_odf_as_string_v(doc, node, prop, \"{pattern}\", error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -240,7 +365,11 @@ class RefObjValidator(IdfValidator):
     def __init__(self):
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_ref_obj(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -260,7 +389,11 @@ class RefObjValidator(IdfValidator):
 
 
 class RefObjArrayValidator(RefObjValidator):
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_ref_obj_v(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -310,7 +443,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int16(<arg_name>)"],
         ["<arg_in> = g_variant_get_int16(<arg_name>)"],
-        IntegerValidator(0x7fff, -(0x8000))
+        IntegerValidator(0x7fff, -(0x8000), True)
     ),
     "uint16": CTypeBase(
         ["guint16 <arg_name>"],
@@ -324,7 +457,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int32(<arg_name>)"],
         ["<arg_in> = g_variant_get_int32(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff, -(0x8000_0000))
+        IntegerValidator(0x7fff_ffff, -(0x8000_0000), True)
     ),
     "uint32": CTypeBase(
         ["guint32 <arg_name>"],
@@ -338,7 +471,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int64(<arg_name>)"],
         ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "uint64": CTypeBase(
         ["guint64 <arg_name>"],
@@ -359,7 +492,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int64(<arg_name>)"],
         ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "double": CTypeBase(
         ["gdouble <arg_name>"],
@@ -373,7 +506,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_handle(<arg_name>)"],
         ["<arg_in> = g_variant_get_handle(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, 0)
+        IntegerValidator(0x7fff_ffff_ffff_ffff, 0, True)
     ),
     "string": CTypeBase(
         ["<const>gchar *<arg_name>"],
@@ -394,7 +527,7 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_signature_encode(<arg_name>)"],
         ["<arg_in> = g_strdup(g_variant_get_string(<arg_name>, NULL))"],
-        StringValidator("^([abynqiuxtdsogv\\{\\}\\(\\)])+$")
+        StringValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$")
     ),
     "variant": CTypeBase(
         ["GVariant *<arg_name>"],
@@ -422,7 +555,7 @@ CTYPE_OBJS = {
         ["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>)"],
-        IntegerArrayValidator(0x7fff, -(0x8000))
+        IntegerArrayValidator(0x7fff, -(0x8000), True)
     ),
     "array[uint16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint16 *<arg_name>"],
@@ -436,7 +569,7 @@ CTYPE_OBJS = {
         ["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>)"],
-        IntegerArrayValidator(0x7fff_ffff, -(0x80000000))
+        IntegerArrayValidator(0x7fff_ffff, -(0x80000000), True)
     ),
     "array[uint32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint32 *<arg_name>"],
@@ -450,7 +583,7 @@ CTYPE_OBJS = {
         ["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>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[uint64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint64 *<arg_name>"],
@@ -464,14 +597,14 @@ CTYPE_OBJS = {
         ["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>)"],
-        IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>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>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],
@@ -485,27 +618,27 @@ CTYPE_OBJS = {
         ["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>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, 0, True)
     ),
     "array[string]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<arg_name>"],
         ["gcl_strfreev_p(&<arg_name>)"],
         ["<arg_out> = gcl_array_string_encode(<arg_name>)"],
         ["<arg_in> = gcl_array_string_decode(<arg_name>)"],
         StringArrayValidator("^.*$")
     ),
     "array[object_path]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<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>)"],
         StringArrayValidator("^(/[A-Z0-9a-z_]+)*$")
     ),
     "array[signature]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<arg_name>"],
         ["gcl_strfreev_p(&<arg_name>)"],
         ["<arg_out> = gcl_array_signature_encode(<arg_name>)"],
         ["<arg_in> = gcl_array_signature_decode(<arg_name>)"],
-        StringArrayValidator("^([abynqiuxtdsogv\\{\\}\\(\\)])+$")
+        StringArrayValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$")
     )
 }

{lbkit-0.5.6 → lbkit-0.5.8}/lbkit/codegen/idf_interface.py

@@ -12,6 +12,8 @@ log = Logger("gen_interface")
 class IDFException(Exception):
     pass
 
+class IdfInterfacePlugin(Renderer):
+    actions = []
 
 class IdfInterfaceBase(Renderer):
     def __init__(self) -> None:
@@ -24,6 +26,7 @@ class IdfInterfaceBase(Renderer):
         self.dictionaries = {}
         self.enumerations = {}
         self.annotations = []
+        self.plugin: IdfInterfacePlugin = None
         self.description = None
         self.version = None
         self.alias = None
@@ -135,6 +138,39 @@ class IdfCtypeRender():
         if match:
             self.ctype = f"array[enum[{match.group(1)}]]"
 
+    def odf_validate(self, allow_ref):
+        log.debug(f"Get odf validate info, name: {self.name}, ctype: {self.ctype}")
+        if "variant" == self.ctype:
+            return []
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if match:
+            if "refobj" in self.flags:
+                valiator = RefObjArrayValidator()
+                return valiator.odf_validate()
+            ctype_obj = CTYPE_OBJS.get(self.ctype)
+            return ctype_obj.validator.odf_validate()
+        match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
+        if match:
+            if "refobj" in self.flags:
+                valiator = RefObjValidator()
+                return valiator.odf_validate()
+            ctype_obj = CTYPE_OBJS.get(self.ctype)
+            return ctype_obj.validator.odf_validate()
+        # 非基础类型
+        is_array = False
+        ctype = self.ctype
+        match = re.match(f"^array\[(.*)\]$", ctype)
+        if match:
+            is_array = True
+            ctype = match.group(1)
+        match = re.match(f"^(struct|enum|dict)\[(.*)\]$", ctype)
+        _, stru_name = get_intfname_and_ctype(match.group(2))
+        if is_array:
+            return [f"_validate_odf_as_{match.group(1)}_{stru_name}_v(doc, node, prop, error_list)"]
+        else:
+            return [f"_validate_odf_as_{match.group(1)}_{stru_name}(doc, node, prop, error_list)"]
+
+
     def odf_schema(self, allow_ref):
         log.debug(f"Get odf schema info, name: {self.name}, ctype: {self.ctype}")
         if "variant" == self.ctype:
@@ -143,16 +179,16 @@ class IdfCtypeRender():
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjArrayValidator()
-                return valiator.odf_schema(allow_ref, {})
+                return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref, {})
+            return ctype_obj.validator.odf_schema(allow_ref)
         match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjValidator()
-                return valiator.odf_schema(allow_ref, {})
+                return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref, {})
+            return ctype_obj.validator.odf_schema(allow_ref)
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -231,7 +267,7 @@ class IdfCtypeRender():
         if match.group(1) == "struct":
             if is_array:
                 # 结构体数组初始化时为二级空指针，以空指针结束
-                return [f"{stru_name} * <const>*<arg_name>"]
+                return [f"{stru_name} *<const>*<arg_name>"]
             else:
                 # 结构体成员初始化时为空结构体，由反序列化时填充内容
                 return [f"<const>{stru_name} *<arg_name>"]
@@ -482,6 +518,7 @@ class IdfBase():
 
 
 class IdfMethod(IdfBase):
+    is_plugin = False
     def __init__(self, intf: IdfInterfaceBase, method_data):
         super().__init__(intf, method_data)
         self.parameters: IdfParameters = IdfParameters(intf, method_data.get("parameters", []))
@@ -529,6 +566,15 @@ class IdfStructure(IdfBase):
         }
         return odf
 
+
+class IdfPluginAction(IdfMethod):
+    is_plugin = True
+
+    def __init__(self, intf: IdfInterfaceBase, method_data):
+        self.policy = method_data.get("policy", "continue_always")
+        super().__init__(intf, method_data)
+
+
 class IdfEnumeration(IdfBase):
     def __init__(self, intf: IdfInterfaceBase, enum_data):
         super().__init__(intf, enum_data)
@@ -652,6 +698,7 @@ class IdfInterface(IdfInterfaceBase):
         self.dictionaries: dict[str, IdfDictionary] = {}
         self.enumerations: dict[str, IdfEnumeration] = {}
         self.annotations: list[IdfAnnotation] = []
+        self.plugin: IdfInterfacePlugin = IdfInterfacePlugin()
         self.description = None
         self.version = None
         self.alias = None
@@ -721,6 +768,15 @@ class IdfInterface(IdfInterfaceBase):
             }
         return odf
 
+    @property
+    def fake_methods(self):
+        methods = []
+        for method in self.methods:
+            methods.append(method)
+        for action in self.plugin.actions:
+            methods.append(action)
+        return methods
+
     def load_elements(self):
         # 使用schema校验数据，确保IDF文件符合格式要求，减少程序处理过程中的异常处理
         # 验证失败时抛异常，此处不用处理，由外层处理
@@ -759,6 +815,12 @@ class IdfInterface(IdfInterfaceBase):
         for item in items:
             obj = IdfEnumeration(self, item)
             self.enumerations[obj.name] = obj
+        plugin = idf.get("plugin", None)
+        if plugin is not None:
+            items = plugin.get("actions", [])
+            for item in items:
+                obj = IdfPluginAction(self, item)
+                self.plugin.actions.append(obj)
         log.debug("interface signature: " + self.signature)
         for signal in self.signals:
             log.debug(f"{signal.name} signature: " + signal.signature)

{lbkit-0.5.6 → lbkit-0.5.8}/lbkit/codegen/template/client.c.mako

@@ -45,6 +45,14 @@ gint ${class_name}_get_${prop.name}(const ${class_name} *object, GVariant **valu
 % endfor
 
 % for method in intf.methods:
+<% RSP_PARA = f'' %>\
+<% REQ_PARA = f'' %>\
+    % if len(method.returns.parameters) > 0:
+<% RSP_PARA = f'{intf.alias}_{method.name}_Rsp **rsp, ' %>\
+    % endif
+    % if len(method.parameters.parameters) > 0:
+<% REQ_PARA = f'const {intf.alias}_{method.name}_Req *req, ' %>\
+    % endif
 /*
  * ${method.description}
  *
@@ -56,8 +64,9 @@ gint ${class_name}_get_${prop.name}(const ${class_name} *object, GVariant **valu
  *   @out_${arg.name}: ${arg.description}, signature: ${arg.signature}
     % endfor
  */
-int ${class_name}_Call_${method.name}(const ${class_name} *object, const ${intf.alias}_${method.name}_Req *req,
-    ${intf.alias}_${method.name}_Rsp **rsp, gint timeout, GError **error)
+int ${class_name}_Call_${method.name}(const ${class_name} *object,
+    ${REQ_PARA}${RSP_PARA}gint timeout,
+    GError **error)
 {
     if (error == NULL) {
         log_error("Emit method ${method.name} with parameter error, error is NULL");
@@ -67,6 +76,12 @@ int ${class_name}_Call_${method.name}(const ${class_name} *object, const ${intf.
         *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Call method ${method.name} with parameter error, object is NULL");
         return -1;
     }
+    % if len(method.returns.parameters) == 0:
+    void **rsp = NULL;
+    % endif
+    % if len(method.parameters.parameters) == 0:
+    void *req = NULL;
+    % endif
     return gcl_impl.call_method((GclObject *)object, (const GclMethod *)&${method_processer}->${method.name},
                                  (void *)req, (void **)rsp, timeout, error);
 }