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), }