lbkit 0.5.17__tar.gz → 0.5.18__tar.gz

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

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

lbkit-0.5.18/lbkit/__init__.py

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

{lbkit-0.5.17 → lbkit-0.5.18}/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.18}/lbkit/codegen/idf_interface.py

@@ -1,11 +1,13 @@
 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
 
 log = Logger("gen_interface")
 
@@ -130,6 +132,7 @@ class IdfCtypeRender():
     intf: IdfInterfaceBase = None
     ctype: str = None
     name: str = ""
+    idf_data = None
     flags: list[str] = []
 
     def __init__(self):
@@ -144,19 +147,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
@@ -500,9 +510,52 @@ 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 == "byte" or self.ctype == "array[byte]" or
+            self.ctype == "int16" or self.ctype == "array[int16]" or
+            self.ctype == "uint16" or self.ctype == "array[uint16]" or
+            self.ctype == "int32" or self.ctype == "array[int32]" or
+            self.ctype == "uint32" or self.ctype == "array[uint32]" or
+            self.ctype == "int64" or self.ctype == "array[int64]" or
+            self.ctype == "uint64" or self.ctype == "array[uint64]"):
+            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")
@@ -548,8 +601,10 @@ class IdfProperty(IdfCtypeRender):
     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", "")

{lbkit-0.5.17 → lbkit-0.5.18}/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}");
@@ -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;

{lbkit-0.5.17 → lbkit-0.5.18}/lbkit/codegen/template/server.c.mako

@@ -44,7 +44,7 @@ ${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
 % if cnt == 0:
     return g_new0(${name}, 1);
 % else:
-    yaml_node_t *val;
+    __attribute__((unused)) yaml_node_t *val;
     ${name} *output = g_new0(${name}, 1);
     GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
     % for prop in stru.values.parameters:
@@ -236,7 +236,6 @@ gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const
 static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
 static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *gcl_obj,
     property_reference_loaded ref_loaded, gpointer user_data);
-static void _valid_from_odf(yaml_document_t *doc, yaml_node_t *node, const gchar *object_name);
 
 static GclInterface _${class_name}_interface = {
     .create = _${intf.alias}_create,
@@ -255,7 +254,7 @@ static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *pro
     const gchar *flags = NULL;
     yaml_node_t *val = g_hash_table_lookup(prop_table, "_${prop.name}_flags");
     if (val && val->type == YAML_SCALAR_NODE) {
-        flags = val->data.scalar.value;
+        flags = (const gchar *)val->data.scalar.value;
     }
     val = g_hash_table_lookup(prop_table, "${prop.name}");
     ## validate接口在加载odf前完成属性是否必选校验，此处如果是必选属性一定存在
@@ -269,8 +268,9 @@ static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *pro
     % if "refobj" in prop.flags:
     ref_loaded(obj, &${properties}.${prop.name}, doc, val, user_data, flags);
     % else:
-    if (val->type == YAML_SCALAR_NODE && val->data.scalar.value[0] == '$' &&
-        g_regex_match(gcl_ref_prop_regex(), val->data.scalar.value, 0, NULL)) {
+    const gchar *val_str  = (const gchar *)val->data.scalar.value;
+    if (val->type == YAML_SCALAR_NODE && val_str[0] == '$' &&
+        g_regex_match(gcl_ref_prop_regex(), val_str, 0, NULL)) {
         ref_loaded(obj, &${properties}.${prop.name}, doc, val, user_data, flags);
     } else {
         % if prop.odf_load_func() is not None:

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

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

lbkit-0.5.17/lbkit/__init__.py

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