Lines Matching refs:self
297 def __init__(self, parser, name, attrs):
298 self.parser = parser
299 self.sections = []
300 self.name = name
301 self.explicit_size = int(attrs["size"]) if "size" in attrs else 0
302 self.size = 0
303 self.align = int(attrs["align"]) if "align" in attrs else None
306 def __init__(self, name):
307 self.name = name
309 def get_size(self):
310 if self.size > 0:
311 return self.size
314 for section in self.sections:
317 if self.explicit_size > 0:
318 assert(self.explicit_size >= size)
319 self.size = self.explicit_size
321 self.size = size
322 return self.size
324 def add_section(self, type_name, attrs):
326 section = self.Section(safe_name(attrs["name"]).lower())
330 section.type = self.parser.structs[attrs["type"]]
332 self.sections.append(section)
335 def __init__(self, parser, attrs):
336 self.parser = parser
338 self.name = safe_name(attrs["name"]).lower()
339 self.human_name = attrs["name"]
343 self.start = (int(word) * 32) + int(bit)
345 self.start = int(attrs["start"])
347 self.end = self.start + int(attrs["size"]) - 1
348 self.type = attrs["type"]
350 if self.type == 'bool' and self.start != self.end:
351 print("#error Field {} has bool type but more than one bit of size".format(self.name));
354 self.prefix = safe_name(attrs["prefix"]).upper()
356 self.prefix = None
359 self.exact = int(attrs["exact"])
361 self.exact = None
363 self.default = attrs.get("default")
366 if self.type in self.parser.enums and self.default is not None:
367 self.default = safe_name('{}_{}_{}'.format(global_prefix, self.type, self.default)).upper()
369 self.modifier = parse_modifier(attrs.get("modifier"))
371 def emit_template_struct(self, dim):
372 if self.type == 'address':
374 elif self.type == 'bool':
376 elif self.type == 'float':
378 elif self.type in ['uint', 'hex'] and self.end - self.start > 32:
380 elif self.type == 'int':
382 elif self.type in ['uint', 'hex', 'uint/float', 'padded', 'Pixel Format']:
384 elif self.type in self.parser.structs:
385 type = 'struct ' + self.parser.gen_prefix(safe_name(self.type.upper()))
386 elif self.type in self.parser.enums:
387 type = 'enum ' + enum_name(self.type)
389 print("#error unhandled type: %s" % self.type)
392 print(" %-36s %s%s;" % (type, self.name, dim))
394 for value in self.values:
395 name = prefixed_upper_name(self.prefix, value.name)
398 def overlaps(self, field):
399 return self != field and max(self.start, field.start) <= min(self.end, field.end)
402 def __init__(self, parser, parent, start, count, label):
403 self.parser = parser
404 self.parent = parent
405 self.start = start
406 self.count = count
407 self.label = label
408 self.size = 0
409 self.length = 0
410 self.fields = []
412 def get_length(self):
414 calculated = max(field.end // 8 for field in self.fields) + 1 if len(self.fields) > 0 else 0
415 if self.length > 0:
416 assert(self.length >= calculated)
418 self.length = calculated
419 return self.length
422 def emit_template_struct(self, dim):
423 if self.count == 0:
426 if self.count > 1:
427 dim = "%s[%d]" % (dim, self.count)
429 if len(self.fields) == 0:
432 for field in self.fields:
439 def __init__(self):
440 self.size = 32
441 self.contributors = []
444 def __init__(self, field, path, start, end):
445 self.field = field
446 self.path = path
447 self.start = start
448 self.end = end
450 def collect_fields(self, fields, offset, path, all_fields):
455 if field.type in self.parser.structs:
456 sub_struct = self.parser.structs[field.type]
457 self.collect_fields(sub_struct.fields, field_offset, field_path + '.', all_fields)
462 all_fields.append(self.FieldRef(field, field_path, start, end))
464 def collect_words(self, fields, offset, path, words):
469 if field.type in self.parser.structs:
470 sub_fields = self.parser.structs[field.type].fields
471 self.collect_words(sub_fields, start, field_path + '.', words)
475 contributor = self.FieldRef(field, field_path, start, end)
480 words[b] = self.Word()
483 def emit_pack_function(self):
484 self.get_length()
487 self.collect_words(self.fields, 0, '', words)
490 for field in self.fields:
505 for index in range(self.length // 4):
544 elif field.type in self.parser.enums:
574 def mask_for_word(self, index, start, end):
584 def emit_unpack_function(self):
587 self.collect_words(self.fields, 0, '', words)
589 for index in range(self.length // 4):
591 word = words.get(index, self.Word())
592 masks = [self.mask_for_word(index, c.start, c.end) for c in word.contributors]
599 print(TMPL.format(index, hex(mask ^ ALL_ONES), self.label, index))
602 self.collect_fields(self.fields, 0, '', fieldrefs)
614 elif field.type in self.parser.enums:
644 def emit_print_function(self):
645 for field in self.fields:
649 if field.type in self.parser.structs:
650 pack_name = self.parser.gen_prefix(safe_name(field.type)).upper()
656 elif field.type in self.parser.enums:
676 def __init__(self, attrs):
677 self.name = attrs["name"]
678 self.value = int(attrs["value"], 0)
681 def __init__(self):
682 self.parser = xml.parsers.expat.ParserCreate()
683 self.parser.StartElementHandler = self.start_element
684 self.parser.EndElementHandler = self.end_element
686 self.struct = None
687 self.structs = {}
689 self.enums = set()
690 self.aggregate = None
691 self.aggregates = {}
693 def gen_prefix(self, name):
696 def start_element(self, name, attrs):
707 self.no_direct_packing = attrs.get("no-direct-packing", False)
708 object_name = self.gen_prefix(safe_name(name.upper()))
709 self.struct = object_name
711 self.group = Group(self, None, 0, 1, name)
713 self.group.length = int(attrs["size"]) * 4
714 self.group.align = int(attrs["align"]) if "align" in attrs else None
715 self.structs[attrs["name"]] = self.group
717 self.group.fields.append(Field(self, attrs))
718 self.values = []
720 self.values = []
721 self.enum = safe_name(attrs["name"])
722 self.enums.add(attrs["name"])
724 self.prefix = attrs["prefix"]
726 self.prefix= None
728 self.values.append(Value(attrs))
730 aggregate_name = self.gen_prefix(safe_name(attrs["name"].upper()))
731 self.aggregate = Aggregate(self, aggregate_name, attrs)
732 self.aggregates[attrs['name']] = self.aggregate
734 type_name = self.gen_prefix(safe_name(attrs["type"].upper()))
735 self.aggregate.add_section(type_name, attrs)
737 def end_element(self, name):
739 self.emit_struct()
740 self.struct = None
741 self.group = None
743 self.group.fields[-1].values = self.values
745 self.emit_enum()
746 self.enum = None
748 self.emit_aggregate()
749 self.aggregate = None
755 def emit_header(self, name):
757 for field in self.group.fields:
762 elif field.type in self.structs:
763 default_fields.append(" .{} = {{ {}_header }}".format(field.name, self.gen_prefix(safe_name(field.type.upper()))))
772 def emit_template_struct(self, name, group):
777 def emit_aggregate(self):
778 aggregate = self.aggregate
794 def emit_pack_function(self, name, group):
803 assert((self.group.length % 4) == 0)
805 print('#define {} {}'.format (name + "_LENGTH", self.group.length))
806 if self.group.align != None:
807 print('#define {} {}'.format (name + "_ALIGN", self.group.align))
808 print('struct {}_packed {{ uint32_t opaque[{}]; }};'.format(name.lower(), self.group.length // 4))
810 def emit_unpack_function(self, name, group):
819 def emit_print_function(self, name, group):
827 def emit_struct(self):
828 name = self.struct
830 self.emit_template_struct(self.struct, self.group)
831 self.emit_header(name)
832 if self.no_direct_packing == False:
833 self.emit_pack_function(self.struct, self.group)
834 self.emit_unpack_function(self.struct, self.group)
835 self.emit_print_function(self.struct, self.group)
837 def enum_prefix(self, name):
840 def emit_enum(self):
841 e_name = enum_name(self.enum)
842 prefix = e_name if self.enum != 'Format' else global_prefix
845 for value in self.values:
854 for value in self.values:
862 def parse(self, filename):
864 self.parser.ParseFile(file)