system_info_generated: Rearrange <enum> be a child of <key>

Previously, the <key> and <enum> are at the same level. Changed it so
that the <key> now adopts an <enum> as a child only when its @type="enum".
The implementation follows the concept that the <enum> is subordinate
to the <key>. That is, the operations of the class 'TizenFeatureEnum'
are controlled by its parent, the class 'TizenFeature'.
  - Parsing 'TizenFeature' is followed by parsing 'TizenFeatureEnum'
  - Printing 'TizenFeature' is followed by printing 'TizenFeatureEnum'

Change-Id: I683c84823f67fce91c8f5703a037f4bf7c24adbf
Signed-off-by: Youngjae Cho <y0.cho@samsung.com>

diff --git a/SystemInfoGenerator/ModelConfigParser.py b/SystemInfoGenerator/ModelConfigParser.py
index 186ee5beef6d4591ca93149ac50b273c67b6447b..ca705f24b773d8827f657903b2ae4fa4267c677d 100644 (file)
--- a/SystemInfoGenerator/ModelConfigParser.py
+++ b/SystemInfoGenerator/ModelConfigParser.py
@@ -19,7 +19,6 @@ class ModelConfigParser:
     def __init__(self, inputs=[]):
         self._inputs = inputs
         self._tizen_features = []
-        self._tizen_enums = []
 
         for f in inputs:
             self.__parse_xml(f)
@@ -30,15 +29,11 @@ class ModelConfigParser:
 
     @property
     def result(self):
-        return self._tizen_features, self._tizen_enums
+        return self._tizen_features
 
     def __parse_xml(self, fname):
         root = et.parse(fname).getroot()
 
-        enums = root.findall('.//enum[@typename]')
-        for enum in enums:
-            self._tizen_enums.append(TizenFeatureEnum(enum))
-
         features = root.findall('.//key[@name][@type][@getter]')
         for feature in features:
             self._tizen_features.append(TizenFeature(feature))

diff --git a/SystemInfoGenerator/SystemInfoGenerator.py b/SystemInfoGenerator/SystemInfoGenerator.py
index 13865fa94fc9490c33b1a237b0c7bec141a1278e..d159b52e2b36e5a680990d986a78ebdfec62fb47 100644 (file)
--- a/SystemInfoGenerator/SystemInfoGenerator.py
+++ b/SystemInfoGenerator/SystemInfoGenerator.py
@@ -19,9 +19,8 @@ from .SystemInfoBoilerplate import Boilerplate as bp
 from .TizenFeature import TizenFeature, TizenFeatureEnum
 
 class SystemInfoGenerator:
-    def __init__(self, features, enums):
+    def __init__(self, features):
         self._features = features
-        self._enums = enums
 
     @redirect_output('source')
     def generate_source(self):
@@ -31,15 +30,13 @@ class SystemInfoGenerator:
             source_header = os.path.basename(get_output_path('header'))
             bp.print_include([source_header])
         for feature in self._features:
-            feature.print_function()
+            feature.print_function_definition()
         bp.print_tail()
 
     @redirect_output('header')
     def generate_header(self):
         bp.print_head(title='system-info-generated', guard='__TIZEN_SYSTEM_SYSTEM_INFO_GENERATED_H__')
         bp.print_include(['system_info.h'])
-        for enum in self._enums:
-            enum.print_enum_declaration()
         for feature in self._features:
-            feature.print_function(body=False)
+            feature.print_function_declaration()
         bp.print_tail(guard='__TIZEN_SYSTEM_SYSTEM_INFO_GENERATED_H__')

diff --git a/SystemInfoGenerator/SystemInfoUtilityGenerator.py b/SystemInfoGenerator/SystemInfoUtilityGenerator.py
index a95512853db11d74551441293a9969c0bc0565a2..6805758e99fea042943e1c8919caed3bad783df4 100644 (file)
--- a/SystemInfoGenerator/SystemInfoUtilityGenerator.py
+++ b/SystemInfoGenerator/SystemInfoUtilityGenerator.py
@@ -19,12 +19,19 @@ from .SystemInfoBoilerplate import Boilerplate as bp
 from .TizenFeature import TizenFeature, TizenFeatureEnum
 
 class SystemInfoUtilityGenerator:
-    def __init__(self, features, enums):
+    def __init__(self, features):
         self._features = features
-        self._enums = enums
 
     def __print_string_enum_mapping_array(self):
         global_enum_set = {}
+        enum_list = []
+
+        for feature in self._features:
+            if feature.enum is None:
+                continue
+
+            enum_list.append(feature.enum)
+
         print(
             dedent('''\
             static struct enumerator {
@@ -32,7 +39,8 @@ class SystemInfoUtilityGenerator:
                 int value;
             } enumerators[] = {''')
         )
-        for enum in self._enums:
+
+        for enum in enum_list:
             for name,value in enum.data.items():
                 if name in global_enum_set:
                     print(f'#error Duplicate enumerator name "{name}"')

diff --git a/SystemInfoGenerator/TizenFeature.py b/SystemInfoGenerator/TizenFeature.py
index cbb717b66e206d5a08074b9385da7a4e1b1428d6..812d52533270e92a3277eb3ada551f4948f433a1 100644 (file)
--- a/SystemInfoGenerator/TizenFeature.py
+++ b/SystemInfoGenerator/TizenFeature.py
@@ -16,9 +16,13 @@ from textwrap import dedent
 
 class TizenFeature:
     def __init__(self, feature):
-        self._name = feature.attrib['name']
-        self._type = feature.attrib['type']
-        self._getter = feature.attrib['getter']
+        self._name = feature.get('name')
+        self._type = feature.get('type')
+        if (self._type == 'enum'):
+            self._enum = TizenFeatureEnum(feature.find('enum'), self._name)
+        else:
+            self._enum = None
+        self._getter = feature.get('getter')
         self._type_casting = ''
         self._broken = False
 
@@ -34,10 +38,12 @@ class TizenFeature:
         elif self.type == 'string':
             self._argtype = 'char **'
             self._system_info = 'system_info_get_platform_string'
-        else:
-            self._argtype = f'{self.type} *'
+        elif self.type == 'enum':
+            self._argtype =  self.enum.typename + ' *'
             self._system_info = 'system_info_get_platform_int'
             self._type_casting = '(int *) '
+        else:
+            print(f'#error Invalid key type: {self.type}')
 
     def __eq__(self, other):
         return self.name == other.name and \
@@ -52,6 +58,10 @@ class TizenFeature:
     def type(self):
         return self._type
 
+    @property
+    def enum(self):
+        return self._enum
+
     @property
     def getter(self):
         return self._getter
@@ -76,34 +86,27 @@ class TizenFeature:
     def broken(self, value):
         self._broken = value
 
-    def print_function(self, body=True):
-        if body:
-            trailing = ''
-            visibility = '__attribute__((visibility("default")))'
-        else:
-            trailing = ';'
-            visibility = ''
+    def print_function_declaration(self):
+        if self.type == 'enum':
+            self.enum.print_enum_declaration()
 
+        print(f'''int system_info_get_{self.getter}({self.argtype}value);\n''')
+
+    def print_function_definition(self):
         print(
             dedent(f'''\
-            {visibility}
-            int system_info_get_{self.getter}({self.argtype}value){trailing}'''
+                __attribute__((visibility("default")))
+                int system_info_get_{self.getter}({self.argtype}value)
+                {{
+                    return {self.system_info}("{self.name}", {self.type_casting}value);
+                }}\n'''
             )
         )
 
-        if not body:
-            return
-
-        print(dedent(f'''\
-            {{
-                return {self.system_info}("{self.name}", {self.type_casting}value);
-            }}''')
-        )
-
-
 class TizenFeatureEnum:
-    def __init__(self, feature):
-        self._typename = feature.attrib['typename']
+    def __init__(self, feature, key_name):
+        self._key_name = key_name
+        self._typename = feature.get('typename')
         self._data = {}
         self._next_value = 0
         self._broken = False
@@ -116,14 +119,15 @@ class TizenFeatureEnum:
                 print('Invalid data name')
                 continue
 
-            if value is None:
-                self.__add_data(name)
-            else:
-                self.__add_data(name, int(value))
+            self.__add_data(name, value)
 
     def __eq__(self, other):
         return self.typename == other.typename and self.data == other.data
 
+    @property
+    def key_name(self):
+        return self._key_name
+
     @property
     def typename(self):
         return self._typename
@@ -140,7 +144,7 @@ class TizenFeatureEnum:
     def broken(self, value):
         self._broken = value
 
-    def __add_data(self, name, value=None):
+    def __add_data(self, name, value):
         if name in self._data:
             print(f'Error: Duplicate data {name}, reject')
             return
@@ -149,12 +153,13 @@ class TizenFeatureEnum:
             value = self._next_value
             self._next_value += 1
         else:
+            value = int(value)
             self._next_value = value + 1
 
         self._data[name] = value
 
     def print_enum_declaration(self):
         print('typedef enum {')
-        for name,value in self._data.items():
+        for name,value in self.data.items():
             print(f'    {name} = {value},')
-        print(f'}} {self._typename};')
+        print(f'}} {self._typename};\n')

diff --git a/SystemInfoGenerator/__main__.py b/SystemInfoGenerator/__main__.py
index 1435cd1718efa9cd95485b058f5291c11f40711f..ba8e8f7931474406d5a90a0933c9a49469de409c 100644 (file)
--- a/SystemInfoGenerator/__main__.py
+++ b/SystemInfoGenerator/__main__.py
@@ -46,10 +46,10 @@ if __name__ == '__main__':
     if args.output_util_header is not None:
         set_output_path('util-header', args.output_util_header)
 
-    features, enums = ModelConfigParser(inputs).result
+    features = ModelConfigParser(inputs).result
 
-    generator = SystemInfoGenerator(features, enums)
-    utility_generator = SystemInfoUtilityGenerator(features, enums)
+    generator = SystemInfoGenerator(features)
+    utility_generator = SystemInfoUtilityGenerator(features)
 
     generator.generate_header()
     generator.generate_source()