Lines Matching refs:self
16 def __init__(self, message):
17 self.message = message
20 def __init__(self, name):
21 self.name = name
22 self.values = []
24 def has_name(self, name):
25 for (n, value) in self.values:
30 def names(self):
31 return [n for (n, value) in self.values]
33 def dump(self):
35 for (name, value) in self.values:
39 print("enum %s {" % self.name)
40 for (name, value) in self.values:
47 def dump_pack_struct(self):
51 def __init__(self, name, low, high, shr, type, parser):
52 self.name = name
53 self.low = low
54 self.high = high
55 self.shr = shr
56 self.type = type
68 if self.type == "boolean" and not low == high:
70 elif self.type == "float" and not (high - low == 31 or high - low == 15):
72 elif not self.type in builtin_types and not self.type in parser.enums:
73 raise parser.error("unknown type '%s'" % self.type)
75 def ctype(self, var_name):
76 if self.type == None:
79 elif self.type == "boolean":
82 elif self.type == "uint" or self.type == "hex" or self.type == "a3xx_regid":
85 elif self.type == "int":
88 elif self.type == "fixed":
90 val = "((int32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
91 elif self.type == "ufixed":
93 val = "((uint32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
94 elif self.type == "float" and self.high - self.low == 31:
97 elif self.type == "float" and self.high - self.low == 15:
100 elif self.type in [ "address", "waddress" ]:
104 type = "enum %s" % self.type
107 if self.shr > 0:
108 val = "(%s >> %d)" % (val, self.shr)
149 def __init__(self, name, template):
150 self.name = name
151 self.inline = False
153 self.fields = template.fields[:]
155 self.fields = []
158 def get_address_field(self):
159 for f in self.fields:
164 def dump_regpair_builder(self, reg):
167 for f in self.fields:
183 for f in self.fields:
194 address = self.get_address_field()
206 def dump_pack_struct(self, reg=None):
213 for f in self.fields:
238 self.dump_regpair_builder(reg)
242 if self.get_address_field():
255 def dump(self, prefix=None):
257 prefix = self.name
258 for f in self.fields:
280 def __init__(self, attrs, domain, variant, parent, index_type):
282 self.local_name = attrs["name"]
284 self.local_name = ""
285 self.domain = domain
286 self.variant = variant
287 self.parent = parent
288 if self.parent:
289 self.name = self.parent.name + "_" + self.local_name
291 self.name = self.local_name
293 self.offsets = map(lambda i: "0x%08x" % int(i, 0), attrs["offsets"].split(","))
294 self.fixed_offsets = True
296 self.offsets = map(lambda s: "(%s)" % s , attrs["doffsets"].split(","))
297 self.fixed_offsets = True
299 self.offset = int(attrs["offset"], 0)
300 self.stride = int(attrs["stride"], 0)
301 self.fixed_offsets = False
303 self.index_type = index_type
305 self.index_type = None
306 self.length = int(attrs["length"], 0)
308 self.usages = attrs["usage"].split(',')
310 self.usages = None
312 def index_ctype(self):
313 if not self.index_type:
316 return "enum %s" % self.index_type.name
319 def indices(self):
320 if self.parent:
321 indices = self.parent.indices()
324 if self.length != 1:
325 if self.fixed_offsets:
326 indices.append((self.index_ctype(), None, "__offset_%s" % self.local_name))
328 indices.append((self.index_ctype(), self.stride, None))
331 def total_offset(self):
333 if not self.fixed_offsets:
334 offset += self.offset
335 if self.parent:
336 offset += self.parent.total_offset()
339 def dump(self):
340 proto = indices_varlist(self.indices())
341 strides = indices_strides(self.indices())
342 array_offset = self.total_offset()
343 if self.fixed_offsets:
344 print("static inline uint32_t __offset_%s(%s idx)" % (self.local_name, self.index_ctype()))
346 if self.index_type:
347 for val, offset in zip(self.index_type.names(), self.offsets):
350 for idx, offset in enumerate(self.offsets):
355 tab_to("#define REG_%s_%s" % (self.domain, self.name), "0x%08x\n" % array_offset)
357 tab_to("#define REG_%s_%s(%s)" % (self.domain, self.name, proto), "(0x%08x + %s )\n" % (array_offset, strides))
359 def dump_pack_struct(self):
362 def dump_regpair_builder(self):
366 def __init__(self, attrs, domain, array, bit_size):
367 self.name = attrs["name"]
368 self.domain = domain
369 self.array = array
370 self.offset = int(attrs["offset"], 0)
371 self.type = None
372 self.bit_size = bit_size
374 self.name = array.name + "_" + self.name
375 self.full_name = self.domain + "_" + self.name
377 self.stride = int(attrs["stride"], 0)
378 self.length = int(attrs["length"], 0)
380 self.stride = None
381 self.length = None
384 def indices(self):
385 if self.array:
386 indices = self.array.indices()
389 if self.stride:
390 indices.append(("uint32_t", self.stride, None))
393 def total_offset(self):
394 if self.array:
395 return self.array.total_offset() + self.offset
397 return self.offset
399 def dump(self):
400 proto = indices_prototype(self.indices())
401 strides = indices_strides(self.indices())
402 offset = self.total_offset()
404 tab_to("#define REG_%s" % self.full_name, "0x%08x" % offset)
406 print("static inline uint32_t REG_%s(%s) { return 0x%08x + %s; }" % (self.full_name, proto, offset, strides))
408 if self.bitset.inline:
409 self.bitset.dump(self.full_name)
411 def dump_pack_struct(self):
412 if self.bitset.inline:
413 self.bitset.dump_pack_struct(self)
415 def dump_regpair_builder(self):
416 if self.bitset.inline:
417 self.bitset.dump_regpair_builder(self)
419 def dump_py(self):
420 print("\tREG_%s = 0x%08x" % (self.full_name, self.offset))
424 def __init__(self):
425 self.current_array = None
426 self.current_domain = None
427 self.current_prefix = None
428 self.current_prefix_type = None
429 self.current_stripe = None
430 self.current_bitset = None
431 self.current_bitsize = 32
434 self.current_varset = None
437 self.variant_regs = {}
440 self.usage_regs = collections.defaultdict(list)
441 self.bitsets = {}
442 self.enums = {}
443 self.variants = set()
444 self.file = []
445 self.xml_files = []
446 self.copyright_year = None
447 self.authors = []
448 self.license = None
450 def error(self, message):
451 parser, filename = self.stack[-1]
454 def prefix(self, variant=None):
455 if self.current_prefix_type == "variant" and variant:
457 elif self.current_stripe:
458 return self.current_stripe + "_" + self.current_domain
459 elif self.current_prefix:
460 return self.current_prefix + "_" + self.current_domain
462 return self.current_domain
464 def parse_field(self, name, attrs):
473 high = self.current_bitsize - 1
485 b = Field(name, low, high, shr, type, self)
490 self.current_bitset.fields.append(b)
492 raise self.error(e)
494 def parse_varset(self, attrs):
496 varset = self.current_varset
498 varset = self.enums[attrs["varset"]]
501 def parse_variants(self, attrs):
508 varset = self.parse_varset(attrs)
514 def add_all_variants(self, reg, attrs, parent_variant):
518 variant = self.parse_variants(attrs)
522 if reg.name not in self.variant_regs:
523 self.variant_regs[reg.name] = {}
526 v = next(iter(self.variant_regs[reg.name]))
527 assert self.variant_regs[reg.name][v].bit_size == reg.bit_size
529 self.variant_regs[reg.name][variant] = reg
531 def add_all_usages(self, reg, usages):
536 self.usage_regs[usage].append(reg)
538 self.variants.add(reg.domain)
540 def do_validate(self, schemafile):
541 if not self.validate:
547 parser, filename = self.stack[-1]
564 raise self.error("Cannot find schema for: " + filename)
572 raise self.error("Schema validation failed for: " + filename + "\n" + error_str)
574 if self.validate:
579 def do_parse(self, filename):
581 if filepath in self.xml_files:
583 self.xml_files.append(filepath)
586 self.stack.append((parser, filename))
587 parser.StartElementHandler = self.start_element
588 parser.EndElementHandler = self.end_element
589 parser.CharacterDataHandler = self.character_data
592 self.stack.pop()
595 def parse(self, rnn_path, filename, validate):
596 self.path = rnn_path
597 self.stack = []
598 self.validate = validate
599 self.do_parse(filename)
601 def parse_reg(self, attrs, bit_size):
602 self.current_bitsize = bit_size
603 if "type" in attrs and attrs["type"] in self.bitsets:
604 bitset = self.bitsets[attrs["type"]]
606 self.current_bitset = Bitset(attrs["name"], bitset)
607 self.current_bitset.inline = True
609 self.current_bitset = bitset
611 self.current_bitset = Bitset(attrs["name"], None)
612 self.current_bitset.inline = True
614 self.parse_field(None, attrs)
616 variant = self.parse_variants(attrs)
617 if not variant and self.current_array:
618 variant = self.current_array.variant
620 self.current_reg = Reg(attrs, self.prefix(variant), self.current_array, bit_size)
621 self.current_reg.bitset = self.current_bitset
623 if len(self.stack) == 1:
624 self.file.append(self.current_reg)
627 self.add_all_variants(self.current_reg, attrs, variant)
632 elif self.current_array:
633 usages = self.current_array.usages
635 self.add_all_usages(self.current_reg, usages)
637 def start_element(self, name, attrs):
638 self.cdata = ""
641 self.do_parse(os.path.join(self.path, filename))
643 self.current_domain = attrs["name"]
645 self.current_prefix = self.parse_variants(attrs)
646 self.current_prefix_type = attrs["prefix"]
648 self.current_prefix = None
649 self.current_prefix_type = None
651 self.current_varset = self.enums[attrs["varset"]]
653 self.current_stripe = self.parse_variants(attrs)
655 self.current_enum_value = 0
656 self.current_enum = Enum(attrs["name"])
657 self.enums[attrs["name"]] = self.current_enum
658 if len(self.stack) == 1:
659 self.file.append(self.current_enum)
664 value = self.current_enum_value
665 self.current_enum.values.append((attrs["name"], value))
667 self.parse_reg(attrs, 32)
669 self.parse_reg(attrs, 64)
671 self.current_bitsize = 32
672 variant = self.parse_variants(attrs)
673 index_type = self.enums[attrs["index"]] if "index" in attrs else None
674 self.current_array = Array(attrs, self.prefix(variant), variant, self.current_array, index_type)
675 if len(self.stack) == 1:
676 self.file.append(self.current_array)
678 self.current_bitset = Bitset(attrs["name"], None)
680 self.current_bitset.inline = True
681 self.bitsets[self.current_bitset.name] = self.current_bitset
682 if len(self.stack) == 1 and not self.current_bitset.inline:
683 self.file.append(self.current_bitset)
684 elif name == "bitfield" and self.current_bitset:
685 self.parse_field(attrs["name"], attrs)
687 self.do_validate(attrs["xsi:schemaLocation"])
689 self.copyright_year = attrs["year"]
691 self.authors.append(attrs["name"] + " <" + attrs["email"] + "> " + attrs["name"])
693 def end_element(self, name):
695 self.current_domain = None
696 self.current_prefix = None
697 self.current_prefix_type = None
699 self.current_stripe = None
701 self.current_bitset = None
703 self.current_reg = None
705 self.current_array = self.current_array.parent
707 self.current_enum = None
709 self.license = self.cdata
711 def character_data(self, data):
712 self.cdata += data
714 def dump_reg_usages(self):
716 for usage, regs in self.usage_regs.items():
718 variants = self.variant_regs.get(reg.name)
724 for variant in self.variants:
729 for usage, regs in self.usage_regs.items():
755 def dump(self):
759 for e in self.file:
770 self.dump_reg_usages()
773 def dump_regs_py(self):
775 for e in self.file:
783 def dump_reg_variants(self, regname, variants):
851 def dump_structs(self):
852 for e in self.file:
855 for regname in self.variant_regs:
856 self.dump_reg_variants(regname, self.variant_regs[regname])