Lines Matching refs:self
8 def __init__(self, message):
9 self.message = message
12 def __init__(self, name):
13 self.name = name
14 self.values = []
16 def dump(self):
19 for (name, value) in self.values:
23 print("enum %s {" % self.name)
24 for (name, value) in self.values:
31 def dump_pack_struct(self):
35 def __init__(self, name, low, high, shr, type, parser):
36 self.name = name
37 self.low = low
38 self.high = high
39 self.shr = shr
40 self.type = type
50 if self.type == "boolean" and not low == high:
52 elif self.type == "float" and not (high - low == 31 or high - low == 15):
54 elif not self.type in builtin_types and not self.type in parser.enums:
55 raise parser.error("unknown type '%s'" % self.type);
57 def ctype(self, var_name):
58 if self.type == None:
61 elif self.type == "boolean":
64 elif self.type == "uint" or self.type == "hex" or self.type == "a3xx_regid":
67 elif self.type == "int":
70 elif self.type == "fixed":
72 val = "((int32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
73 elif self.type == "ufixed":
75 val = "((uint32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
76 elif self.type == "float" and self.high - self.low == 31:
79 elif self.type == "float" and self.high - self.low == 15:
82 elif self.type in [ "address", "waddress" ]:
86 type = "enum %s" % self.type
89 if self.shr > 0:
90 val = "(%s >> %d)" % (val, self.shr)
104 def __init__(self, name, template):
105 self.name = name
106 self.inline = False
108 self.fields = template.fields[:]
110 self.fields = []
112 def dump_pack_struct(self, prefix=None, array=None, bit_size=32):
127 prefix = self.name
131 for f in self.fields:
152 for f in self.fields:
164 for f in self.fields:
180 for f in self.fields:
211 def dump(self, prefix=None):
213 prefix = self.name
214 for f in self.fields:
236 def __init__(self, attrs, domain):
238 self.name = attrs["name"]
240 self.name = ""
241 self.domain = domain
242 self.offset = int(attrs["offset"], 0)
243 self.stride = int(attrs["stride"], 0)
244 self.length = int(attrs["length"], 0)
246 def dump(self):
247 print("#define REG_%s_%s(i0) (0x%08x + 0x%x*(i0))\n" % (self.domain, self.name, self.offset, self.stride))
249 def dump_pack_struct(self):
253 def __init__(self, attrs, domain, array, bit_size):
254 self.name = attrs["name"]
255 self.domain = domain
256 self.array = array
257 self.offset = int(attrs["offset"], 0)
258 self.type = None
259 self.bit_size = bit_size
261 if self.array:
262 self.full_name = self.domain + "_" + self.array.name + "_" + self.name
264 self.full_name = self.domain + "_" + self.name
266 def dump(self):
267 if self.array:
268 offset = self.array.offset + self.offset
269 print("static inline uint32_t REG_%s(uint32_t i0) { return 0x%08x + 0x%x*i0; }" % (self.full_name, offset, self.array.stride))
271 tab_to("#define REG_%s" % self.full_name, "0x%08x" % self.offset)
273 if self.bitset.inline:
274 self.bitset.dump(self.full_name)
277 def dump_pack_struct(self):
278 if self.bitset.inline:
279 self.bitset.dump_pack_struct(self.full_name, not self.array == None, self.bit_size)
292 def __init__(self):
293 self.current_array = None
294 self.current_domain = None
295 self.current_prefix = None
296 self.current_stripe = None
297 self.current_bitset = None
298 self.bitsets = {}
299 self.enums = {}
300 self.file = []
302 def error(self, message):
303 parser, filename = self.stack[-1]
306 def prefix(self):
307 if self.current_stripe:
308 return self.current_stripe + "_" + self.current_domain
309 elif self.current_prefix:
310 return self.current_prefix + "_" + self.current_domain
312 return self.current_domain
314 def parse_field(self, name, attrs):
335 b = Field(name, low, high, shr, type, self)
340 self.current_bitset.fields.append(b)
342 raise self.error(e);
344 def do_parse(self, filename):
347 self.stack.append((parser, filename))
348 parser.StartElementHandler = self.start_element
349 parser.EndElementHandler = self.end_element
351 self.stack.pop()
354 def parse(self, rnn_path, filename):
355 self.path = rnn_path
356 self.stack = []
357 self.do_parse(filename)
359 def parse_reg(self, attrs, bit_size):
360 if "type" in attrs and attrs["type"] in self.bitsets:
361 bitset = self.bitsets[attrs["type"]]
363 self.current_bitset = Bitset(attrs["name"], bitset)
364 self.current_bitset.inline = True
366 self.current_bitset = bitset
368 self.current_bitset = Bitset(attrs["name"], None)
369 self.current_bitset.inline = True
371 self.parse_field(None, attrs)
373 self.current_reg = Reg(attrs, self.prefix(), self.current_array, bit_size)
374 self.current_reg.bitset = self.current_bitset
376 if len(self.stack) == 1:
377 self.file.append(self.current_reg)
379 def start_element(self, name, attrs):
382 self.do_parse(os.path.join(self.path, filename))
384 self.current_domain = attrs["name"]
386 self.current_prefix = parse_variants(attrs)
388 self.current_stripe = parse_variants(attrs)
390 self.current_enum_value = 0
391 self.current_enum = Enum(attrs["name"])
392 self.enums[attrs["name"]] = self.current_enum
393 if len(self.stack) == 1:
394 self.file.append(self.current_enum)
399 value = self.current_enum_value
400 self.current_enum.values.append((attrs["name"], value))
401 # self.current_enum_value = value + 1
403 self.parse_reg(attrs, 32)
405 self.parse_reg(attrs, 64)
407 self.current_array = Array(attrs, self.prefix())
408 if len(self.stack) == 1:
409 self.file.append(self.current_array)
411 self.current_bitset = Bitset(attrs["name"], None)
413 self.current_bitset.inline = True
414 self.bitsets[self.current_bitset.name] = self.current_bitset
415 if len(self.stack) == 1 and not self.current_bitset.inline:
416 self.file.append(self.current_bitset)
417 elif name == "bitfield" and self.current_bitset:
418 self.parse_field(attrs["name"], attrs)
420 def end_element(self, name):
422 self.current_domain = None
423 self.current_prefix = None
425 self.current_stripe = None
427 self.current_bitset = None
429 self.current_reg = None
431 self.current_array = None;
433 self.current_enum = None
435 def dump(self):
439 for e in self.file:
450 def dump_structs(self):
451 for e in self.file: