lbkit 0.5.17__tar.gz → 0.5.19__tar.gz

{lbkit-0.5.17/lbkit.egg-info → lbkit-0.5.19}/PKG-INFO

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

lbkit-0.5.19/lbkit/__init__.py

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

{lbkit-0.5.17 → lbkit-0.5.19}/lbkit/codegen/ctype_defination.py

@@ -5,9 +5,11 @@ from lbkit.errors import OdfValidateException
 
 class IdfValidator():
     validator = {}
+    name = ""
 
-    def set_validator(self, value):
+    def set_validator(self, value, name):
         self.validator = value
+        self.name = name
 
     def odf_validate(self):
         idf_validator = idf_validator
@@ -84,8 +86,8 @@ class IntegerValidator(IdfValidator):
             raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}")
         super().__init__()
 
-    def set_validator(self, value):
-        super().set_validator(value)
+    def set_validator(self, value, name):
+        super().set_validator(value, name)
         max = self.validator.get("max", self.maximum)
         if max > self.maximum:
             max = self.maximum
@@ -97,20 +99,23 @@ class IntegerValidator(IdfValidator):
         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}")
+            raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}, property {name} validation failed")
 
     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)")
+            min_str = self.minimum
+            max_str = self.maximum
+            if self.minimum <= -9223372036854775808:
+                min_str = "G_MININT64"
+            if self.maximum >= 9223372036854775807:
+                max_str = "G_MAXINT64"
+            func.append(f"validate_odf_as_signed(doc, node, prop, {max_str}, {min_str}, 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)")
+            max_str = f"{self.maximum}UL"
+            if self.maximum >= 18446744073709551615:
+                max_str = "G_MAXUINT64"
+            func.append(f"validate_odf_as_unsigned(doc, node, prop, {max_str}, {self.minimum}UL, error_list)")
         return func
 
     def odf_schema(self, allow_ref):
@@ -142,21 +147,21 @@ class IntegerValidator(IdfValidator):
 class IntegerArrayValidator(IntegerValidator):
     def odf_validate(self):
         func = []
-        min = self.minimum
-        max = self.maximum
+        min_str = f"{self.minimum}UL"
+        max_str = f"{self.maximum}UL"
         if self.signed:
-            if self.minimum <= -0x8000_0000_0000_0000:
-                min = "G_MININT64"
+            if self.minimum <= -9223372036854775808:
+                min_str = "G_MININT64"
             if self.maximum >= 0x7fff_ffff_ffff_ffff:
-                max = "G_MAXINT64"
+                max_str = "G_MAXINT64"
         else:
             if self.maximum >= 0xffff_ffff_ffff_ffff:
-                max = "G_MAXUINT64"
+                max_str = "G_MAXUINT64"
 
         if self.signed:
-            func.append(f"validate_odf_as_signed_v(doc, node, prop, {max}, {min}, error_list)")
+            func.append(f"validate_odf_as_signed_v(doc, node, prop, {max_str}, {min_str}, error_list)")
         else:
-            func.append(f"validate_odf_as_unsigned_v(doc, node, prop, {max}, {min}, error_list)")
+            func.append(f"validate_odf_as_unsigned_v(doc, node, prop, {max_str}, {min_str}, error_list)")
         return func
 
     def odf_schema(self, allow_ref):
@@ -199,18 +204,18 @@ class FloatValidator(IdfValidator):
     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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_min(doc, node, prop, {self.minimum}, error_list)")
         return func
 
-    def set_validator(self, value):
-        super().set_validator(value)
+    def set_validator(self, value, name):
+        super().set_validator(value, name)
         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)
@@ -256,14 +261,14 @@ class FloatArrayValidator(FloatValidator):
     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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_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)")
+            func.append(f"validate_odf_as_double_min_v(doc, node, prop, {self.minimum}, error_list)")
         return func
 
     def odf_schema(self, allow_ref):
@@ -294,9 +299,9 @@ class StringValidator(IdfValidator):
         self.pattern = pattern
         super().__init__()
 
-    def set_validator(self, value):
+    def set_validator(self, value, name):
+        super().set_validator(value, name)
         self.pattern = self.validator.get("pattern", self.pattern)
-        super().set_validator(value)
 
     def odf_validate(self):
         func = []

{lbkit-0.5.17 → lbkit-0.5.19}/lbkit/codegen/idf_interface.py

@@ -1,11 +1,14 @@
 import yaml
 import os
 import re
+import copy
 import hashlib
 from lbkit.log import Logger
 from lbkit.codegen.renderer import Renderer
 from lbkit.codegen.ctype_defination import CTYPE_OBJS, RefObjArrayValidator, RefObjValidator
 from lbkit.misc import load_yml_with_json_schema_validate
+from lbkit.errors import OdfValidateException
+from lbkit.helper import SigInvalidException, validate_glib_signature
 
 log = Logger("gen_interface")
 
@@ -130,6 +133,8 @@ class IdfCtypeRender():
     intf: IdfInterfaceBase = None
     ctype: str = None
     name: str = ""
+    idf_data = None
+    default = None
     flags: list[str] = []
 
     def __init__(self):
@@ -144,19 +149,26 @@ class IdfCtypeRender():
         if "variant" == self.ctype:
             return []
         match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        validator_cfg = self.validator_cfg
         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()
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return 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()
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_validate()
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -176,20 +188,27 @@ class IdfCtypeRender():
         log.debug(f"Get odf schema info, name: {self.name}, ctype: {self.ctype}")
         if "variant" == self.ctype:
             return None
+        validator_cfg = self.validator_cfg
         match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjArrayValidator()
                 return valiator.odf_schema(allow_ref)
-            ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return 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)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_schema(allow_ref)
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -500,9 +519,50 @@ class IdfCtypeRender():
             else:
                 return f"<arg_name> = _load_odf_as_{stru_name}(doc, <node>)"
 
+    @property
+    def validator_cfg(self):
+        cfg = {}
+        if (self.ctype == "string" or self.ctype == "array[string]" or
+            self.ctype == "object_path" or self.ctype == "array[object_path]" or
+            self.ctype == "signature" or self.ctype == "array[signature]"):
+            value = self.idf_data.get("pattern")
+            if value:
+                cfg["pattern"] = value
+        elif self.ctype in ["byte", "array[byte]", "int16", "array[int16]",
+                            "uint16", "array[uint16]", "int32", "array[int32]",
+                            "uint32", "array[uint32]","int64", "array[int64]",
+                            "uint64", "array[uint64]", "size", "array[size]",
+                            "ssize", "array[ssize]"]:
+            value = self.idf_data.get("max")
+            if value:
+                cfg["max"] = value
+            value = self.idf_data.get("min")
+            if value:
+                cfg["min"] = value
+        if self.ctype == "double" or self.ctype == "array[double]":
+            emin = self.idf_data.get("exclusive_min")
+            if emin:
+                cfg["exclusive_min"] = emin
+            emax = self.idf_data.get("exclusive_max")
+            if emax:
+                cfg["exclusive_max"] = emax
+            mmin = self.idf_data.get("min")
+            if mmin:
+                cfg["min"] = mmin
+            mmax = self.idf_data.get("max")
+            if mmax:
+                cfg["max"] = mmax
+            if mmax is not None and emax is not None:
+                raise OdfValidateException(f"Cannot set max and exclusive_max at the same time, property {self.name} validation failed")
+            if mmin is not None and emin is not None:
+                raise OdfValidateException(f"Cannot set min and exclusive_min at the same time, property {self.name} validation failed")
+        return cfg
+
+
 class IdfProperty(IdfCtypeRender):
     def __init__(self, intf: IdfInterfaceBase, prop_data):
         self.intf = intf
+        self.idf_data = prop_data
         self.ctype = prop_data.get("type", "")
         super().__init__()
         self.name = prop_data.get("name")
@@ -543,13 +603,136 @@ class IdfProperty(IdfCtypeRender):
         else:
             self.desc_flags = " | ".join(c_flags)
 
+        self._load_default()
+
+    def _load_default(self):
+        # 只有基础类型有default值
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if not match:
+            match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
+        if not match:
+            return
+        self.default = self.idf_data.get("default")
+        if self.default is None:
+            return
+
+        if self.ctype in ["boolean", "array[boolean]"]:
+            return
+        pattern = self.idf_data.get("pattern")
+        if pattern:
+            if self.ctype == "string":
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+                return
+            if self.ctype == "array[string]":
+                for val in self.default:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+                return
+        if self.ctype == "object_path":
+            if pattern:
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            match = re.match(f"^(/[A-Z0-9a-z_]+)+$", self.default)
+            if not match:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {self.default}")
+            return
+        if self.ctype == "array[object_path]":
+            for val in self.default:
+                if pattern:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+                match = re.match(f"^(/[A-Z0-9a-z_]+)+$", val)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {val}")
+            return
+
+        if self.ctype == "signature":
+            try:
+                validate_glib_signature(self.default)
+                if pattern:
+                    match = re.match(pattern, self.default)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+        if self.ctype == "array[oobject_path]":
+            try:
+                for val in self.default:
+                    validate_glib_signature(val)
+                    if pattern:
+                        match = re.match(pattern, self.default)
+                        if not match:
+                            raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+
+        cfg = self.validator_cfg
+        if self.ctype in ["byte", "int16", "uint16", "int32", "uint32", "size", "ssize",
+                          "int64", "uint64"]:
+            mmax = cfg.get("max")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            mmin = cfg.get("min")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {mmin}")
+            return
+        if self.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[size]",
+                          "array[ssize]", "array[int64]", "array[uint64]"]:
+            for val in self.default:
+                mmax = cfg.get("max")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                mmin = cfg.get("min")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {mmin}")
+            return
+
+        if self.ctype == "double":
+            emax = cfg.get("exclusive_max")
+            mmax = cfg.get("max")
+            if emax is not None and emax <= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, eclusive_max: {emax}")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            emin = cfg.get("exclusive_min")
+            mmin = cfg.get("min")
+            if emin is not None and emin >= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, exclusive_min: {emin}")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {emin}")
+            return
+        if self.ctype == "array[double]":
+            for val in self.default:
+                emax = cfg.get("exclusive_max")
+                mmax = cfg.get("max")
+                if emax is not None and emax <= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, eclusive_max: {emax}")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                emin = cfg.get("exclusive_min")
+                mmin = cfg.get("min")
+                if emin is not None and emin >= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, exclusive_min: {emin}")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {emin}")
+            return
+        raise OdfValidateException(f"Only basic type(byaqiuxtdsog) support default value, Property {self.name} type is {self.ctype}")
 
     @property
     def signature(self):
         return ctype_to_variant_signature(self.intf, self.ctype)
 
+
 class IdfParameter(IdfCtypeRender):
     def __init__(self, intf: IdfInterfaceBase, para_data):
+        self.idf_data = para_data
         self.intf = intf
         self.name = para_data.get("name")
         self.ctype = para_data.get("type", "")
@@ -764,8 +947,8 @@ class IdfDictionary():
 
 class IdfInterface(IdfInterfaceBase):
     def __init__(self, lookup, idf_file):
-        if not idf_file.endswith(".yaml"):
-            raise IDFException(f"IDF file {idf_file} not endswith .yaml")
+        if not idf_file.endswith(".yaml") and not idf_file.endswith(".yml"):
+            raise IDFException(f"IDF file {idf_file} neither endswith .yaml nor endswith .yml")
         super().__init__()
         self.lookup = lookup
         self.file = idf_file
@@ -865,7 +1048,7 @@ class IdfInterface(IdfInterfaceBase):
         # 使用schema校验数据，确保IDF文件符合格式要求，减少程序处理过程中的异常处理
         # 验证失败时抛异常，此处不用处理，由外层处理
         idf = load_yml_with_json_schema_validate(self.file, "/usr/share/litebmc/schema/idf.v1.json")
-        log.info(f"validate {self.file} successfully")
+        log.debug(f"validate {self.file} successfully")
         self.version = idf.get("version")
         self.description = idf.get("description", "")
         # 别名
@@ -919,19 +1102,17 @@ class IdfInterface(IdfInterfaceBase):
         self.structures[self.alias] = intf_stru
 
     def render_dbus_xml(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
         hash = hashlib.sha256()
         hash.update(out.encode('utf-8'))
         self.introspect_xml_sha256 = hash.hexdigest()
         log.info("The sha256sum of interface {} is {}".format(out_file, self.introspect_xml_sha256))
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)
 
     def render_c_source(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)

{lbkit-0.5.17 → lbkit-0.5.19}/lbkit/codegen/template/public.c.mako

@@ -6,21 +6,21 @@
 % for name, stru in intf.structures.items():
 /* ${name} structure object */
 /* START: 结构体${name}及其数组类型的ODF校验函数 */
-static gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-static gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
 
 % endfor
 ## 定义枚举ODF加载函数
 % for name, enum in intf.enumerations.items():
 /* START: 枚举${name}及其数组类型的ODF校验函数 */
-static gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-static gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
 
 % endfor
 ## 定义字典ODF加载函数
 % for name, dictionary in intf.dictionaries.items():
-static gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-static gboolean _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean __attribute__((unused)) _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
 
 % endfor
 % for name, stru in intf.structures.items():
@@ -36,7 +36,7 @@ GVariant *${name}_encode(const ${name} *value)
         value = &default_val;
     }
     % endif
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     GVariantBuilder builder;
     const gchar *sig = "${stru.signature}";
     g_variant_builder_init(&builder, G_VARIANT_TYPE(sig));
@@ -56,7 +56,7 @@ GVariant *${name}_encode(const ${name} *value)
 ${name} *${name}_decode(GVariant *in)
 {
     GVariantIter iter;
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     ${name} *output = g_new0(${name}, 1);
     if (!in) {
         return output;
@@ -161,9 +161,9 @@ gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node
             "the node type of property %s is not a mapping, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
         return FALSE;
     }
-    gsize len = prop->len;
+    __attribute__((unused)) gsize len = prop->len;
     gboolean valid = TRUE;
-    yaml_node_t *val;
+    __attribute__((unused)) yaml_node_t *val;
     GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
     % for prop in stru.values.parameters:
     val = g_hash_table_lookup(prop_table, "${prop.name}");
@@ -282,7 +282,7 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     }
     ${name} *output = g_new0(${name}, *n);
     while (g_variant_iter_loop(&iter, "s", &str_val)) {
-        for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        for (int i = 0; i < ${len(enum.values.parameters)}; i++) {
             if (g_strcmp0(str_val, _${name}StrMap[i]) == 0) {
                 output[id++] = (${name})i;
             }
@@ -501,7 +501,7 @@ static void ${name}_foreach_encode(${key_declare}, ${name}${dictionary.key} *val
     g_assert(value && dict_builder);
     % endif
 
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     GVariantBuilder builder;
     % if len(dictionary.values.parameters) == 1:
     ## 当只有一个成员时直接添加值
@@ -563,7 +563,6 @@ ${name} *${name}_decode(GVariant *in)
     % if len(dictionary.values.parameters) > 1:
     GVariantIter item_iter;
     % endif
-    GVariant *next_item = NULL;
     GVariant *next_mem = NULL;
 
     ${name} *dict = ${name}_new();
@@ -824,7 +823,7 @@ GVariant *${class_name}_${method.name}_Req_encode(${class_name}_${method.name}_R
     if (!value) {
         value = &default_val;
     }
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     GVariantBuilder builder;
     const gchar *sig = "${method.in_signature}";
     g_variant_builder_init(&builder, G_VARIANT_TYPE(sig));
@@ -842,7 +841,7 @@ GVariant *${class_name}_${method.name}_Req_encode(${class_name}_${method.name}_R
 ${class_name}_${method.name}_Req *${class_name}_${method.name}_Req_decode(GVariant *in)
 {
     GVariantIter iter;
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     ${class_name}_${method.name}_Req *output = g_new0(${class_name}_${method.name}_Req, 1);
     if (!in) {
         return output;
@@ -885,7 +884,7 @@ GVariant *${class_name}_${method.name}_Rsp_encode(${class_name}_${method.name}_R
     if (!value) {
         value = &default_val;
     }
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     GVariantBuilder builder;
     const gchar *sig = "${method.out_signature}";
     g_variant_builder_init(&builder, G_VARIANT_TYPE(sig));
@@ -903,7 +902,7 @@ GVariant *${class_name}_${method.name}_Rsp_encode(${class_name}_${method.name}_R
 ${class_name}_${method.name}_Rsp *${class_name}_${method.name}_Rsp_decode(GVariant *in)
 {
     GVariantIter iter;
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     ${class_name}_${method.name}_Rsp *output = g_new0(${class_name}_${method.name}_Rsp, 1);
     if (!in) {
         return output;
@@ -1077,7 +1076,7 @@ GVariant *${class_name}_${signal.name}_Msg_encode(${class_name}_${signal.name}_M
     if (!value) {
         value = &default_val;
     }
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     GVariantBuilder builder;
     const gchar *sig = "${signal.signature}";
     g_variant_builder_init(&builder, G_VARIANT_TYPE(sig));
@@ -1095,7 +1094,7 @@ GVariant *${class_name}_${signal.name}_Msg_encode(${class_name}_${signal.name}_M
 ${class_name}_${signal.name}_Msg *${class_name}_${signal.name}_Msg_decode(GVariant *in)
 {
     GVariantIter iter;
-    GVariant *tmp = NULL;
+    __attribute__((unused)) GVariant *tmp = NULL;
     ${class_name}_${signal.name}_Msg *output = g_new0(${class_name}_${signal.name}_Msg, 1);
     if (!in) {
         return output;
@@ -1162,7 +1161,7 @@ static gboolean _validate_odf_prop_${prop.name}(yaml_document_t *doc, GHashTable
         if (!node) {
     ## 检查属性是否存在
     % if "required" in prop.flags:
-            *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_MISSING, "Property %s is missing", prop->str));
+            *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_MISSING, "Property ${prop.name} is missing"));
             valid = FALSE;
     % endif
             break;