Lines Matching refs:self
256 def __init__(self, parser, attrs):
257 self.parser = parser
259 self.name = safe_name(attrs["name"])
260 self.start = int(attrs["start"])
261 self.end = int(attrs["end"])
262 self.type = attrs["type"]
263 self.nonzero = bool_from_str(attrs.get("nonzero", "false"))
265 assert self.start <= self.end, \
266 'field {} has end ({}) < start ({})'.format(self.name, self.end,
267 self.start)
268 if self.type == 'bool':
269 assert self.end == self.start, \
270 'bool field ({}) is too wide'.format(self.name)
273 self.prefix = attrs["prefix"]
275 self.prefix = None
279 self.default = int(attrs["default"], base=0)
281 self.default = None
283 ufixed_match = Field.ufixed_pattern.match(self.type)
285 self.type = 'ufixed'
286 self.fractional_size = int(ufixed_match.group(2))
288 sfixed_match = Field.sfixed_pattern.match(self.type)
290 self.type = 'sfixed'
291 self.fractional_size = int(sfixed_match.group(2))
293 def is_builtin_type(self):
297 return self.type in builtins
299 def is_struct_type(self):
300 return self.type in self.parser.structs
302 def is_enum_type(self):
303 return self.type in self.parser.enums
305 def emit_template_struct(self, dim):
306 if self.type == 'address':
308 elif self.type == 'bool':
310 elif self.type == 'float':
312 elif self.type == 'ufixed':
314 elif self.type == 'sfixed':
316 elif self.type == 'uint' and self.end - self.start > 32:
318 elif self.type == 'offset':
320 elif self.type == 'int':
322 elif self.type == 'uint':
324 elif self.is_struct_type():
325 type = 'struct ' + self.parser.gen_prefix(safe_name(self.type))
326 elif self.is_enum_type():
327 type = 'enum ' + self.parser.gen_prefix(safe_name(self.type))
328 elif self.type == 'mbo' or self.type == 'mbz':
331 print("#error unhandled type: %s" % self.type)
334 print(" %-36s %s%s;" % (type, self.name, dim))
336 prefix = self.prefix + '_' if self.prefix else ''
338 for value in self.values:
340 if self.prefix and value.name[0] == '_':
346 def __init__(self, parser, parent, start, count, size):
347 self.parser = parser
348 self.parent = parent
349 self.start = start
350 self.count = count
351 self.size = size
352 self.fields = []
354 def emit_template_struct(self, dim):
355 if self.count == 0:
358 if self.count > 1:
359 dim = "%s[%d]" % (dim, self.count)
361 for field in self.fields:
365 def __init__(self):
366 self.size = 32
367 self.fields = []
368 self.address = None
370 def collect_dwords(self, dwords, start, dim):
371 for field in self.fields:
384 dwords[index] = self.DWord()
407 def collect_dwords_and_length(self):
409 self.collect_dwords(dwords, 0, "")
415 if self.size > 0:
416 length = self.size // 32
424 def emit_pack_function(self, dwords, length):
449 (self.parser.gen_prefix(safe_name(field.type)), index, name))
461 (self.parser.gen_prefix(safe_name(field.type)), index, field_index, name))
551 def __init__(self, attrs):
552 self.name = safe_name(attrs["name"])
553 self.value = ast.literal_eval(attrs["value"])
556 def __init__(self):
557 self.parser = xml.parsers.expat.ParserCreate()
558 self.parser.StartElementHandler = self.start_element
559 self.parser.EndElementHandler = self.end_element
561 self.instruction = None
562 self.structs = {}
564 self.enums = set()
565 self.registers = {}
567 def gen_prefix(self, name):
569 return 'GFX%s%s' % (self.gen, name)
570 return 'GFX%s_%s' % (self.gen, name)
572 def gen_guard(self):
573 return self.gen_prefix("PACK_H")
575 def start_element(self, name, attrs):
577 self.platform = attrs["name"]
578 self.gen = attrs["gen"].replace('.', '')
579 print(pack_header % {'license': license, 'platform': self.platform, 'guard': self.gen_guard()})
582 self.instruction = safe_name(attrs["name"])
583 self.length_bias = int(attrs["bias"])
585 self.instruction_engines = set(attrs["engine"].split('|'))
590 self.instruction_engines = None
592 self.struct = safe_name(attrs["name"])
593 self.structs[attrs["name"]] = 1
595 self.register = safe_name(attrs["name"])
596 self.reg_num = num_from_str(attrs["num"])
597 self.registers[attrs["name"]] = 1
599 self.length = int(attrs["length"])
600 size = self.length * 32
602 self.length = None
604 self.group = Group(self, None, 0, 1, size)
607 group = Group(self, self.group,
609 self.group.fields.append(group)
610 self.group = group
612 self.group.fields.append(Field(self, attrs))
613 self.values = []
615 self.values = []
616 self.enum = safe_name(attrs["name"])
617 self.enums.add(attrs["name"])
619 self.prefix = safe_name(attrs["prefix"])
621 self.prefix= None
623 self.values.append(Value(attrs))
625 def end_element(self, name):
627 self.emit_instruction()
628 self.instruction = None
629 self.group = None
631 self.emit_struct()
632 self.struct = None
633 self.group = None
635 self.emit_register()
636 self.register = None
637 self.reg_num = None
638 self.group = None
640 self.group = self.group.parent
642 self.group.fields[-1].values = self.values
644 self.emit_enum()
645 self.enum = None
647 print('#endif /* %s */' % self.gen_guard())
649 def emit_template_struct(self, name, group):
650 print("struct %s {" % self.gen_prefix(name))
654 def emit_pack_function(self, name, group):
655 name = self.gen_prefix(name)
672 def emit_instruction(self):
673 name = self.instruction
674 if self.instruction_engines and not self.instruction_engines & self.engines:
677 if not self.length is None:
679 (self.gen_prefix(name + "_length"), self.length))
681 (self.gen_prefix(name + "_length_bias"), self.length_bias))
684 for field in self.group.fields:
695 default_fields.append(" .%-35s = (enum %s) %6d" % (field.name, self.gen_prefix(safe_name(field.type)), field.default))
698 print('#define %-40s\\' % (self.gen_prefix(name + '_header')))
702 self.emit_template_struct(self.instruction, self.group)
704 self.emit_pack_function(self.instruction, self.group)
706 def emit_register(self):
707 name = self.register
708 if not self.reg_num is None:
710 (self.gen_prefix(name + "_num"), self.reg_num))
712 if not self.length is None:
714 (self.gen_prefix(name + "_length"), self.length))
716 self.emit_template_struct(self.register, self.group)
717 self.emit_pack_function(self.register, self.group)
719 def emit_struct(self):
720 name = self.struct
721 if not self.length is None:
723 (self.gen_prefix(name + "_length"), self.length))
725 self.emit_template_struct(self.struct, self.group)
726 self.emit_pack_function(self.struct, self.group)
728 def emit_enum(self):
729 print('enum %s {' % self.gen_prefix(self.enum))
730 for value in self.values:
731 if self.prefix:
732 name = self.prefix + "_" + value.name
738 def parse(self, filename):
740 self.parser.ParseFile(file)