Debian Codegraph @

build-aux/qmi-codegen/VariableStruct.py

raw
1 # -*- Mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 #
3 # This program is free software; you can redistribute it and/or modify it under
4 # the terms of the GNU Lesser General Public License as published by the Free
5 # Software Foundation; either version 2 of the License, or (at your option) any
6 # later version.
7 #
8 # This program is distributed in the hope that it will be useful, but WITHOUT
9 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
10 # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
11 # details.
12 #
13 # You should have received a copy of the GNU Lesser General Public License along
14 # with this program; if not, write to the Free Software Foundation, Inc., 51
15 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 #
17 # Copyright (C) 2012 Lanedo GmbH
18 # Copyright (C) 2012-2022 Aleksander Morgado <[email protected]>
19 # Copyright (c) 2022 Qualcomm Innovation Center, Inc.
20 #
21
22 import string
23 import utils
24 from Variable import Variable
25 import VariableFactory
26
27 """
28 Variable type for Structs ('struct' format)
29 These variables are exclusively used as array elements, they can not be used as
30 independent TLVs. Use Sequence instead for that.
31 """
32 class VariableStruct(Variable):
33
34 def __init__(self, service, dictionary, struct_type_name, container_type):
35
36 # Call the parent constructor
37 Variable.__init__(self, service, dictionary)
38
39 self.container_type = container_type
40
41 # The public format of the struct is built directly from the suggested
42 # struct type name
43 self.struct_type_name = struct_type_name
44 self.element_type = utils.build_camelcase_name(self.struct_type_name)
45 self.public_format = self.element_type
46 self.private_format = self.public_format
47
48 self.since = dictionary['since'] if 'since' in dictionary else ''
49
50 # Load members of this struct
51 self.members = []
52 for member_dictionary in dictionary['contents']:
53 member = {}
54 member['name'] = utils.build_underscore_name(member_dictionary['name'])
55 member['object'] = VariableFactory.create_variable(self.service, member_dictionary, struct_type_name + ' ' + member_dictionary['name'], self.container_type)
56 # Specify that the variable will be defined in the public header
57 member['object'].flag_public()
58 self.members.append(member)
59
60 # We'll need to dispose if at least one of the members needs it
61 for member in self.members:
62 if member['object'].needs_dispose:
63 self.needs_dispose = True
64 break
65
66 if self.needs_dispose:
67 self.clear_method = '__' + utils.build_underscore_name(self.struct_type_name) + '_clear'
68
69
70 # When using structs, we always require GIR compat methods because they're going
71 # to be stored via reference pointers in the arrays
72 self.needs_compat_gir = True
73
74 # If any of the contents needs GIR compat methods, then we must also create a new
75 # GIR compat struct type; otherwise just use the original one
76 self.content_needs_compat_gir = False
77 for member in self.members:
78 if member['object'].needs_compat_gir:
79 self.content_needs_compat_gir = True
80 break
81
82 if self.content_needs_compat_gir:
83 self.struct_type_name_gir = self.struct_type_name + ' Gir'
84 else:
85 self.struct_type_name_gir = self.struct_type_name
86 self.element_type_gir = utils.build_camelcase_name(self.struct_type_name_gir)
87 self.public_format_gir = self.element_type_gir
88 self.private_format_gir = self.public_format_gir
89 self.new_method_gir = '__' + utils.build_underscore_name(self.struct_type_name_gir) + '_new'
90 self.free_method_gir = '__' + utils.build_underscore_name(self.struct_type_name_gir) + '_free'
91
92 # We'll contain personal info if at least one of the members contains personal info or we ourselves are personal info
93 if not self.contains_personal_info:
94 for member in self.members:
95 if member['object'].contains_personal_info:
96 self.contains_personal_info = True
97 break
98
99
100 def build_variable_declaration(self, line_prefix, variable_name):
101 raise RuntimeError('Variable of type "struct" can only be defined as array members')
102
103
104 def build_struct_field_declaration(self, line_prefix, variable_name):
105 raise RuntimeError('Variable of type "struct" cannot be defined as struct fields')
106
107
108 def emit_types(self, hfile, cfile, since, static):
109 for member in self.members:
110 member['object'].emit_types(hfile, cfile, since, static)
111
112 translations = { 'format' : self.public_format,
113 'since' : since if not self.since else self.since }
114 template = '\n'
115 hfile.write(string.Template(template).substitute(translations))
116
117 if not static and self.service != 'CTL':
118 template = (
119 '\n'
120 '/**\n')
121 if self.content_needs_compat_gir:
122 template += (
123 ' * ${format}: (skip)\n')
124 else:
125 template += (
126 ' * ${format}:\n')
127 hfile.write(string.Template(template).substitute(translations))
128 for member in self.members:
129 hfile.write(member['object'].build_struct_field_documentation(' * ', member['name']))
130 template = (
131 ' *\n'
132 ' * A ${format} struct.\n'
133 ' *\n'
134 ' * Since: ${since}\n'
135 ' */\n')
136 hfile.write(string.Template(template).substitute(translations))
137
138 template = (
139 'typedef struct _${format} {\n')
140 hfile.write(string.Template(template).substitute(translations))
141
142 for member in self.members:
143 hfile.write(member['object'].build_struct_field_declaration(' ', member['name']))
144
145 template = ('} ${format};\n')
146 hfile.write(string.Template(template).substitute(translations))
147
148 # No need for the clear func if no need to dispose the contents
149 if self.needs_dispose:
150 translations['clear_method'] = self.clear_method
151 template = (
152 '\n'
153 'static void\n'
154 '${clear_method} (${format} *value)\n'
155 '{\n')
156 for member in self.members:
157 template += member['object'].build_dispose(' ', 'value->' + member['name'])
158 template += (
159 '}\n')
160 cfile.write(string.Template(template).substitute(translations))
161
162
163 def emit_types_gir(self, hfile, cfile, since):
164 for member in self.members:
165 member['object'].emit_types_gir(hfile, cfile, since)
166
167 translations = { 'element_type_no_gir' : self.public_format,
168 'element_type' : self.element_type_gir,
169 'underscore' : utils.build_underscore_name(self.struct_type_name_gir),
170 'new_method' : self.new_method_gir,
171 'free_method' : self.free_method_gir,
172 'since' : since if utils.version_compare('1.32',since) > 0 else '1.32' }
173
174 # The type emission should happen ONLY if the GIR required type is
175 # different to the original one
176 if self.content_needs_compat_gir:
177 template = (
178 '\n'
179 '/**\n'
180 ' * ${element_type}: (rename-to ${element_type_no_gir})\n')
181 hfile.write(string.Template(template).substitute(translations))
182 for member in self.members:
183 hfile.write(member['object'].build_struct_field_documentation_gir(' * ', member['name']))
184 template = (
185 ' *\n'
186 ' * A ${element_type} struct.\n'
187 ' *\n'
188 ' * This type is a version of #${element_type_no_gir}, using arrays of pointers to\n'
189 ' * structs instead of arrays of structs, for easier binding in other languages.\n'
190 ' *\n'
191 ' * Since: ${since}\n'
192 ' */\n')
193 hfile.write(string.Template(template).substitute(translations))
194
195 template = (
196 'typedef struct _${element_type} {\n')
197 hfile.write(string.Template(template).substitute(translations))
198 for member in self.members:
199 hfile.write(member['object'].build_struct_field_declaration_gir(' ', member['name']))
200 template = (
201 '} ${element_type};\n')
202 hfile.write(string.Template(template).substitute(translations))
203
204 # Free and New methods are required always for the GIR required type,
205 # regardless of whether it's different to the original one or the same
206 template = (
207 '\n'
208 'static void\n'
209 '${free_method} (${element_type} *value)\n'
210 '{\n')
211 if not self.content_needs_compat_gir and self.needs_dispose:
212 translations['clear_method'] = self.clear_method
213 template += ' ${clear_method} (value);\n'
214 else:
215 for member in self.members:
216 template += member['object'].build_dispose_gir(' ', 'value->' + member['name'])
217 template += (
218 ' g_slice_free (${element_type}, value);\n'
219 '}\n'
220 '\n'
221 'static ${element_type} *\n'
222 '${new_method} (void)\n'
223 '{\n'
224 ' return g_slice_new0 (${element_type});\n'
225 '}\n')
226 cfile.write(string.Template(template).substitute(translations))
227
228 template = (
229 '\n'
230 'GType ${underscore}_get_type (void) G_GNUC_CONST;\n')
231 hfile.write(string.Template(template).substitute(translations))
232
233 template = (
234 '\n'
235 'static ${element_type} *\n'
236 '__${underscore}_copy (const ${element_type} *value)\n'
237 '{\n'
238 ' ${element_type} *copy;\n'
239 '\n'
240 ' copy = ${new_method} ();\n')
241 template += self.build_copy_gir(' ', 'value', 'copy')
242 template += (
243 ' return copy;\n'
244 '}\n'
245 '\n'
246 'G_DEFINE_BOXED_TYPE (${element_type}, ${underscore}, (GBoxedCopyFunc)__${underscore}_copy, (GBoxedFreeFunc)__${underscore}_free)\n')
247 cfile.write(string.Template(template).substitute(translations))
248
249
250 def emit_buffer_read(self, f, line_prefix, tlv_out, error, variable_name):
251 for member in self.members:
252 member['object'].emit_buffer_read(f, line_prefix, tlv_out, error, variable_name + '.' + member['name'])
253
254
255 def emit_buffer_write(self, f, line_prefix, tlv_name, variable_name):
256 for member in self.members:
257 member['object'].emit_buffer_write(f, line_prefix, tlv_name, variable_name + '.' + member['name'])
258
259
260 def emit_get_printable(self, f, line_prefix, is_personal):
261 translations = { 'lp' : line_prefix }
262
263 template = (
264 '${lp}g_string_append (printable, "[");\n')
265 f.write(string.Template(template).substitute(translations))
266
267 for member in self.members:
268 translations['variable_name'] = member['name']
269 template = (
270 '${lp}g_string_append (printable, " ${variable_name} = \'");\n')
271 f.write(string.Template(template).substitute(translations))
272
273 member['object'].emit_get_printable(f, line_prefix, self.personal_info or is_personal)
274
275 template = (
276 '${lp}g_string_append (printable, "\'");\n')
277 f.write(string.Template(template).substitute(translations))
278
279 template = (
280 '${lp}g_string_append (printable, " ]");\n')
281 f.write(string.Template(template).substitute(translations))
282
283
284 def build_dispose(self, line_prefix, variable_name):
285 translations = { 'lp' : line_prefix,
286 'underscore' : utils.build_underscore_name(self.struct_type_name),
287 'variable_name' : variable_name }
288
289 template = '${lp}${underscore}_clear (&${variable_name});\n'
290 return string.Template(template).substitute(translations)
291
292
293 def build_dispose_gir(self, line_prefix, variable_name):
294 translations = { 'lp' : line_prefix,
295 'underscore' : utils.build_underscore_name(self.struct_type_name_gir),
296 'variable_name' : variable_name }
297
298 template = '${lp}${underscore}_free (${variable_name});\n'
299 return string.Template(template).substitute(translations)
300
301
302 def build_copy_to_gir(self, line_prefix, variable_name_from, variable_name_to):
303 translations = { 'lp' : line_prefix,
304 'element_type_gir' : self.element_type_gir,
305 'variable_name_to' : variable_name_to,
306 'variable_name_from' : variable_name_from }
307
308 template = ''
309 for member in self.members:
310 template += member['object'].build_copy_to_gir(line_prefix,
311 '${variable_name_from}.' + member['name'],
312 '${variable_name_to}->' + member['name'])
313 return string.Template(template).substitute(translations)
314
315
316 def build_copy_from_gir(self, line_prefix, variable_name_from, variable_name_to):
317 translations = { 'lp' : line_prefix,
318 'element_type_gir' : self.element_type_gir,
319 'variable_name_to' : variable_name_to,
320 'variable_name_from' : variable_name_from }
321
322 template = ''
323 for member in self.members:
324 template += member['object'].build_copy_from_gir(line_prefix,
325 '${variable_name_from}->' + member['name'],
326 '${variable_name_to}.' + member['name'])
327 return string.Template(template).substitute(translations)
328
329
330 def build_copy_gir(self, line_prefix, variable_name_from, variable_name_to):
331 translations = { 'lp' : line_prefix,
332 'element_type_gir' : self.element_type_gir,
333 'variable_name_to' : variable_name_to,
334 'variable_name_from' : variable_name_from }
335
336 template = ''
337 for member in self.members:
338 template += member['object'].build_copy_gir(line_prefix,
339 '${variable_name_from}->' + member['name'],
340 '${variable_name_to}->' + member['name'])
341 return string.Template(template).substitute(translations)
342
343
344 def add_sections(self, sections):
345 for member in self.members:
346 member['object'].add_sections(sections)
347
348 sections['public-types'] += self.element_type + '\n'
349 sections['standard'] += utils.build_underscore_name(self.struct_type_name) + '_get_type\n'
350 if self.content_needs_compat_gir:
351 sections['public-types'] += self.element_type_gir + '\n'
352 sections['standard'] += utils.build_underscore_name(self.struct_type_name_gir) + '_get_type\n'