def _create_entry(self, field):
"""
Look at self.parse for full documentation.
This looks at <subfield> fields of the <field> to create the union entries.
"""
xml_subfields = field.findall('subfield')
xml_subfields.append(
field) #Weird, but true. <value> can be in <field> too.
name = get_name(field)
field_name = trim_name(name)
field_bits = field.get('num_bits', -1)
try:
int(field_bits)
except Exception:
logging.error('%s failed to parse bits to int: %s' %
(name, field_bits))
return None
enum_instance = None
result = []
for xml_subfield in xml_subfields:
xml_values = xml_subfield.findall('value')
if xml_values is None or len(
xml_values) == 0: # No value - not an enum
continue
if xml_subfield != field:
subfield_name: str = get_name(xml_subfield)
subfield_name = trim_name(subfield_name)
else:
subfield_name = ''
inst_name = 'genz_%s_%s' % (field_name, subfield_name)
#empty subfield_name produces trailing '_'. Thus - clean it up.
inst_name = inst_name.strip('_')
enum_instance = fields.CEnumEntry(inst_name,
origin=xml_subfield,
parent=field)
for xml_value in xml_values:
entry_name = get_name(xml_value)
entry_name = trim_name(entry_name)
if entry_name == 'reserved':
continue
entry_name = '%s_%s_%s' % (field_name, subfield_name,
entry_name)
entry_name = trim_name(entry_name)
entry_name = entry_name.upper()
val = xml_value.get('val', -1)
entry = fields.EStateEntry(entry_name, val)
entry.origin = field
enum_instance.append(entry)
self._instance.append(enum_instance)
result.append(enum_instance)
return result
def parse(self, root):
"""
Generate a struct array of "meta" structs describing a Class. Refere
to "struct_meta" property for documentation on the meta values.
@param root: xml root tree to start parsing from.
"""
if root is None:
return
if self._instance is None:
self._instance = fields.CArrayEntry(self.name, 'struct %s' % self.struct_name)
list_of_names = []
longest_name_length = self._get_longest_name_length(root)
for class_elem in root:
raw_name = get_name(class_elem)
trimmed_name = raw_name.lower().split('(')[0].strip()
name = trim_name(trimmed_name, replaceable=' —[:](),=.\n', removable='\'|!<>@#$%^&*+–’-/')
if 'switch' in name:
name = 'switch'
if 'bridge' in trimmed_name:
name = 'bridge'
if name not in list_of_names:
list_of_names.append(name)
enum_index = len(self.enum.entries)
estate = fields.EStateEntry('GENZ_%s' % name.upper(), enum_index)
spaces = ' ' * (longest_name_length - len(raw_name))
# { raw_name, condenced_name, condenced_enum_value }
name = '"%s", %s"%s", %s' % (raw_name, spaces, name, estate.name)
struct_entry = fields.CStructEntry(name, ignore_long_name_warning=True)
struct_entry.l_space = '%s { ' % struct_entry.l_space
struct_entry.str_close_symbol = ' },'
self._instance.append(struct_entry)
self.enum.append(estate)
last_state = fields.EStateEntry('GENZ_NUM_HARDWARE_TYPES', None)
self.enum.append(last_state)
return self.instance
def build_ctrl_struct_type_enum(cls, structs: list, start_index=0):
"""
enum genz_control_structure_type {
GENZ_GENERIC_STRUCTURE = -1,
GENZ_UNKNOWN_STRUCTURE = -2,
genz_core_structure = 0,
genz_opcode_set_structure = 1,
genz_interface_structure = 2,
....
"""
struct = fields.CEnumEntry(cls.ctrl_struct_type_enum_name)
#FIXME: those two lines below needs to be refactored into something more
# portable. Can't rely on getting the Index for the structure, since
# more special case types could be added, therefore will need to refactor
# every index in the rest of the code using this.
generic_entry = fields.EStateEntry('GENZ_GENERIC_STRUCTURE', -1)
unknown_entry = fields.EStateEntry('GENZ_UNKNOWN_STRUCTURE', -2)
struct.extend([unknown_entry, generic_entry])
table_index = 0
for index in range(len(structs)):
s = structs[index]
if s.is_ignore_ctrl_struct_enum:
continue
value = s.index
#FIXME: this is stupid! Need to index Table entries to start from 1000
# while the struct entries index from 0 to whatever.
if s.tag == 'table':
if table_index == 0:
value = '%s' % cls.table_index_define().name
else:
value = '%s + %s' % (cls.table_index_define().name,
table_index)
table_index += 1
entry = fields.EStateEntry(s.name.upper(), value)
struct.append(entry)
return struct
def pointer_types():
return {
'none':
fields.EStateEntry('GENZ_CONTROL_POINTER_NONE', 0),
'generic':
fields.EStateEntry('GENZ_CONTROL_POINTER_STRUCTURE', 1),
'struct':
fields.EStateEntry('GENZ_CONTROL_POINTER_STRUCTURE', 1),
'chained':
fields.EStateEntry('GENZ_CONTROL_POINTER_CHAINED', 2),
'array':
fields.EStateEntry('GENZ_CONTROL_POINTER_ARRAY', 3),
'table':
fields.EStateEntry('GENZ_CONTROL_POINTER_TABLE', 4),
'tbl_w_hdr':
fields.EStateEntry('GENZ_CONTROL_POINTER_TABLE_WITH_HEADER', 5),
}
def build_export_symbol(self, name):
"""
EXPORT_SYMBOL(genz_struct_type_to_ptrs);
size_t genz_struct_type_to_ptrs_nelems =
sizeof(genz_struct_emtype_to_ptrs) /
sizeof(genz_struct_type_to_ptrs[0]);
EXPORT_SYMBOL(genz_struct_type_to_ptrs);
"""
export_symbol = 'EXPORT_SYMBOL(%s)'
value = 'sizeof({name}) / sizeof({name}[0])'.format(name=name)
return [
fields.CStructEntry(export_symbol % name, var_type='', l_space=''),
fields.EStateEntry('size_t %s_nelems' % name,
value,
l_space='',
close_bracket=';'),
fields.CStructEntry(export_symbol % (name + '_nelems'),
var_type='',
l_space=''),
]
def pointer_sizes():
return {
'4': fields.EStateEntry('GENZ_4_BYTE_POINTER', 4),
'6': fields.EStateEntry('GENZ_6_BYTE_POINTER', 6),
}