lbkit 0.7.1__tar.gz → 0.7.3__tar.gz

{lbkit-0.7.1/lbkit.egg-info → lbkit-0.7.3}/PKG-INFO

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

lbkit-0.7.3/lbkit/__init__.py

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

{lbkit-0.7.1 → lbkit-0.7.3}/lbkit/codegen/codegen.py

@@ -17,7 +17,7 @@ from lbkit.misc import SmartFormatter
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 log = Logger("codegen")
 
-__version__=4
+__version__=5
 
 class CodeGen(object):
     def __init__(self, args):
@@ -55,7 +55,7 @@ class CodeGen(object):
 
     def get_interface(self, idf_file):
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
-        return IdfInterface(lookup, idf_file)
+        return IdfInterface(lookup, idf_file, __version__)
 
     def run(self):
         """

{lbkit-0.7.1 → lbkit-0.7.3}/lbkit/codegen/idf_interface.py

@@ -35,6 +35,7 @@ class IdfInterfaceBase(Renderer):
         self.description = None
         self.version = None
         self.alias = None
+        self.codegen_version: int = 0
 
 class IdfAnnotation():
     def __init__(self, name, value):
@@ -929,7 +930,10 @@ class IdfEnumeration(IdfBase):
     def odf_schema(self):
         values = []
         for prop in self.values.parameters:
-            val = self.intf.name + "." + self.name + "." + prop.name
+            if self.intf.codegen_version >= 5:
+                val = self.intf.name + "." + self.name + "." + prop.name
+            else:
+                val = prop.name
             values.append(val)
 
         odf = {
@@ -1030,7 +1034,7 @@ class IdfDictionary():
 
 
 class IdfInterface(IdfInterfaceBase):
-    def __init__(self, lookup, idf_file):
+    def __init__(self, lookup, idf_file, codegen_version):
         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__()
@@ -1049,6 +1053,7 @@ class IdfInterface(IdfInterfaceBase):
         self.description = None
         self.version = None
         self.alias = None
+        self.codegen_version = codegen_version
         self.load_elements()
 
     @cached_property
@@ -1069,7 +1074,7 @@ class IdfInterface(IdfInterfaceBase):
             if not realpath:
                 raise FileNotFoundError(f"Dependency interface {intf} not exist")
             log.debug(f"Found dependency interface: {realpath}")
-            deps[intf] = (IdfInterface(self.lookup, realpath))
+            deps[intf] = (IdfInterface(self.lookup, realpath, self.codegen_version))
         return deps
 
     @cached_property

{lbkit-0.7.1 → lbkit-0.7.3}/lbkit/codegen/template/public.c.mako

@@ -265,6 +265,49 @@ gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *no
 
 %endfor
 % for name, enum in intf.enumerations.items():
+% if codegen_version >= 5:
+## 枚举序列化和反序列化函数
+static const gchar *_${name}StrMap[] = {
+% for value in enum.values.parameters:
+    "${value.name}",
+% endfor
+};
+
+const gchar *${name}_as_string(${name} value)
+{
+    if (value >= _${name}_Invalid) {
+        return "_Invalid";
+    }
+    return _${name}StrMap[value];
+}
+
+/* ${name}枚举类型序列化（enum转string）函数 */
+GVariant *${name}_encode(${name} value)
+{
+    ## 非法值返回com.litebmc.Errors.Enum.Invalid
+    if (value > ${name}_${enum.values.parameters[len(enum.values.parameters) - 1].name}) {
+        return g_variant_new_string("_Invalid");
+    }
+    return g_variant_new_string(_${name}StrMap[value]);
+}
+
+/* ${name}枚举类型反序列化（string转enum）函数 */
+${name} ${name}_decode(GVariant *in)
+{
+    if (!in) {
+        return _${name}_Invalid;
+    }
+
+    const gchar *in_val = g_variant_get_string(in, NULL);
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0(in_val, _${name}StrMap[i]) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}_Invalid;
+}
+
+% else:
 ## 枚举序列化和反序列化函数
 static const gchar *_${name}StrMap[] = {
 % for value in enum.values.parameters:
@@ -306,6 +349,7 @@ ${name} ${name}_decode(GVariant *in)
     return _${name}Invalid;
 }
 
+% endif
 /* ${name}枚举类型序列化（enum转string）函数 */
 GVariant *${name}_encode_v(const ${name} *values, gsize n)
 {

{lbkit-0.7.1 → lbkit-0.7.3}/lbkit/codegen/template/public.h.mako

@@ -60,7 +60,11 @@ typedef enum {
     % for value in enum.values.parameters:
     ${name}_${value.name},
     % endfor
+% if codegen_version >= 5:
+    _${name}_Invalid,
+% else:
     _${name}Invalid,
+% endif
 } ${name};
 const gchar *${name}_as_string(${name} value);
 

{lbkit-0.7.1 → lbkit-0.7.3}/lbkit/codegen/template/server.c.mako

@@ -86,6 +86,19 @@ struct _${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node
 % for name, enum in intf.enumerations.items():
 ${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
 {
+% if codegen_version >= 5:
+    g_assert(node->type == YAML_SCALAR_NODE);
+    if (node->type != YAML_SCALAR_NODE) {
+        return _${name}_Invalid;
+    }
+
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0((const gchar *)node->data.scalar.value, ${name}_as_string(i)) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}_Invalid;
+% else:
     g_assert(node->type == YAML_SCALAR_NODE);
     if (node->type != YAML_SCALAR_NODE) {
         return _${name}Invalid;
@@ -97,6 +110,7 @@ ${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
         }
     }
     return _${name}Invalid;
+% endif
 }
 
 ${name} *_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node, gsize *n)

{lbkit-0.7.1 → lbkit-0.7.3/lbkit.egg-info}/PKG-INFO

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

{lbkit-0.7.1 → lbkit-0.7.3}/test/test_codegen.py

@@ -4,8 +4,9 @@ import os
 import tracemalloc
 
 tracemalloc.start()
-from lbkit.codegen.idf_interface import IdfInterface, IdfProperty
+from lbkit.codegen.idf_interface import IdfInterface
 from lbkit import errors
+from lbkit.codegen.codegen import __version__ as codegen_version
 
 schema_dir = os.path.realpath(os.path.join(os.getcwd(), "..", "schema"))
 
@@ -86,39 +87,39 @@ class TestCodeGenClass(unittest.TestCase):
 
     def test_validate_default_bool(self):
         self.validate_boolean("b", "boolean", "true")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "false")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "False")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "True")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "ONsdf")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "asdaffa")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_array_bool(self):
         self.validate_boolean("b", "array[boolean]", "[false, true]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "array[boolean]", "[on, 1]")
         # boolean值比较特殊，由json schema校验验证
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def validate_number(self, name, type):
         self.mk_interface_with_number_property(name, type, "100", "1", "1")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "100")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "0")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "101")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_byte(self):
         self.validate_number("y", "byte")
@@ -152,15 +153,15 @@ class TestCodeGenClass(unittest.TestCase):
 
     def validate_array_number(self, name, type):
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[1, 1]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[100, 100]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[0, 0]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[101, 101]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_array_byte(self):
         self.validate_array_number("y", "byte")
@@ -195,88 +196,88 @@ class TestCodeGenClass(unittest.TestCase):
     def test_validate_array_double(self):
         self.mk_interface_with_double_property("double", f"array[double]", "[1, 1]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[100, 100]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[0.9, 0.9]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[100.1, 100.1]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_double(self):
         self.mk_interface_with_double_property("double", "double", "1", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "100", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "0.9", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "100.1", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_string(self):
         self.mk_interface_with_string_property("string", "string", None, "as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "ass")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "asss")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "a")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "0.123")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_array_string(self):
         self.mk_interface_with_string_property("string", "array[string]", None, "[as, as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[as, as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[ass, ass]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[asss, asss]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[a, a]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[0.123, 0.123]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_object_path(self):
         self.mk_interface_with_string_property("object_path", "object_path", None, "/as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "a/s")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s/")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_array_object_path(self):
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/as, /as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s, /a]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[a/s, a/s]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s/, /a/s/]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
 
 if __name__ == "__main__":

lbkit-0.7.1/lbkit/__init__.py

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