Lines Matching refs:self
97 def __init__(self, parser, attrs):
98 self.parser = parser
100 self.name = safe_name(attrs["name"]).lower()
103 self.start = int(attrs["start"][:-1]) * 8
105 self.start = int(attrs["start"])
110 self.start += 8
112 self.end = self.start + int(attrs["size"]) - 1
113 self.type = attrs["type"]
115 if self.type == 'bool' and self.start != self.end:
116 print("#error Field {} has bool type but more than one bit of size".format(self.name));
119 self.prefix = safe_name(attrs["prefix"]).upper()
121 self.prefix = None
124 self.default = int(attrs["default"])
126 self.default = None
130 self.minus_one = True
132 self.minus_one = False
134 ufixed_match = Field.ufixed_pattern.match(self.type)
136 self.type = 'ufixed'
137 self.fractional_size = int(ufixed_match.group(2))
139 sfixed_match = Field.sfixed_pattern.match(self.type)
141 self.type = 'sfixed'
142 self.fractional_size = int(sfixed_match.group(2))
144 def emit_template_struct(self, dim):
145 if self.type == 'address':
147 elif self.type == 'bool':
149 elif self.type == 'float':
151 elif self.type == 'f187':
153 elif self.type == 'ufixed':
155 elif self.type == 'sfixed':
157 elif self.type == 'uint' and self.end - self.start > 32:
159 elif self.type == 'offset':
161 elif self.type == 'int':
163 elif self.type == 'uint':
165 elif self.type in self.parser.structs:
166 type = 'struct ' + self.parser.gen_prefix(safe_name(self.type))
167 elif self.type in self.parser.enums:
168 type = 'enum ' + self.parser.gen_prefix(safe_name(self.type))
169 elif self.type == 'mbo':
172 print("#error unhandled type: %s" % self.type)
175 print(" %-36s %s%s;" % (type, self.name, dim))
177 for value in self.values:
178 name = prefixed_upper_name(self.prefix, value.name)
181 def overlaps(self, field):
182 return self != field and max(self.start, field.start) <= min(self.end, field.end)
186 def __init__(self, parser, parent, start, count):
187 self.parser = parser
188 self.parent = parent
189 self.start = start
190 self.count = count
191 self.size = 0
192 self.fields = []
193 self.min_ver = 0
194 self.max_ver = 0
196 def emit_template_struct(self, dim):
197 if self.count == 0:
200 if self.count > 1:
201 dim = "%s[%d]" % (dim, self.count)
203 for field in self.fields:
207 def __init__(self):
208 self.size = 8
209 self.fields = []
210 self.address = None
212 def collect_bytes(self, bytes):
213 for field in self.fields:
219 bytes[b] = self.Byte()
227 def emit_pack_function(self, start):
229 self.length = max(field.end // 8 for field in self.fields) + 1
232 self.collect_bytes(bytes)
237 for field in self.fields:
241 for index in range(self.length):
269 if not any(field.overlaps(scan_field) for scan_field in self.fields):
307 elif field.type in self.parser.enums:
330 elif field.type in self.parser.structs:
352 def emit_unpack_function(self, start):
353 for field in self.fields:
366 elif field.type in self.parser.enums:
395 def __init__(self, attrs):
396 self.name = attrs["name"]
397 self.value = int(attrs["value"])
400 def __init__(self, ver):
401 self.parser = xml.parsers.expat.ParserCreate()
402 self.parser.StartElementHandler = self.start_element
403 self.parser.EndElementHandler = self.end_element
405 self.packet = None
406 self.struct = None
407 self.structs = {}
409 self.enums = set()
410 self.registers = {}
411 self.ver = ver
413 def gen_prefix(self, name):
415 return 'V3D%s%s' % (self.ver, name)
417 return 'V3D%s_%s' % (self.ver, name)
419 def gen_guard(self):
420 return self.gen_prefix("PACK_H")
422 def attrs_version_valid(self, attrs):
423 if "min_ver" in attrs and self.ver < attrs["min_ver"]:
426 if "max_ver" in attrs and self.ver > attrs["max_ver"]:
431 def group_enabled(self):
432 if self.group.min_ver != 0 and self.ver < self.group.min_ver:
435 if self.group.max_ver != 0 and self.ver > self.group.max_ver:
440 def start_element(self, name, attrs):
442 self.platform = "V3D {}.{}".format(self.ver[0], self.ver[1])
443 print(pack_header % {'license': license, 'platform': self.platform, 'guard': self.gen_guard()})
447 object_name = self.gen_prefix(safe_name(attrs["name"].upper()))
449 self.packet = object_name
462 self.struct = object_name
463 self.structs[attrs["name"]] = 1
465 self.register = object_name
466 self.reg_num = num_from_str(attrs["num"])
467 self.registers[attrs["name"]] = 1
469 self.group = Group(self, None, 0, 1)
471 field = Field(self, default_field)
473 self.group.fields.append(field)
476 self.group.min_ver = attrs["min_ver"]
478 self.group.max_ver = attrs["max_ver"]
481 self.group.fields.append(Field(self, attrs))
482 self.values = []
484 self.values = []
485 self.enum = safe_name(attrs["name"])
486 self.enums.add(attrs["name"])
487 self.enum_enabled = self.attrs_version_valid(attrs)
489 self.prefix = attrs["prefix"]
491 self.prefix= None
493 if self.attrs_version_valid(attrs):
494 self.values.append(Value(attrs))
496 def end_element(self, name):
498 self.emit_packet()
499 self.packet = None
500 self.group = None
502 self.emit_struct()
503 self.struct = None
504 self.group = None
506 self.emit_register()
507 self.register = None
508 self.reg_num = None
509 self.group = None
511 self.group.fields[-1].values = self.values
513 if self.enum_enabled:
514 self.emit_enum()
515 self.enum = None
517 print('#endif /* %s */' % self.gen_guard())
519 def emit_template_struct(self, name, group):
524 def emit_pack_function(self, name, group):
533 (name + "_length", self.group.length))
535 def emit_unpack_function(self, name, group):
545 def emit_header(self, name):
547 for field in self.group.fields:
558 def emit_packet(self):
559 if not self.group_enabled():
562 name = self.packet
564 assert(self.group.fields[0].name == "opcode")
566 (name + "_opcode", self.group.fields[0].default))
568 self.emit_header(name)
569 self.emit_template_struct(self.packet, self.group)
570 self.emit_pack_function(self.packet, self.group)
571 self.emit_unpack_function(self.packet, self.group)
575 def emit_register(self):
576 if not self.group_enabled():
579 name = self.register
580 if not self.reg_num == None:
582 (self.gen_prefix(name + "_num"), self.reg_num))
584 self.emit_template_struct(self.register, self.group)
585 self.emit_pack_function(self.register, self.group)
586 self.emit_unpack_function(self.register, self.group)
588 def emit_struct(self):
589 if not self.group_enabled():
592 name = self.struct
594 self.emit_header(name)
595 self.emit_template_struct(self.struct, self.group)
596 self.emit_pack_function(self.struct, self.group)
597 self.emit_unpack_function(self.struct, self.group)
601 def emit_enum(self):
602 print('enum %s {' % self.gen_prefix(self.enum))
603 for value in self.values:
605 if self.prefix:
606 name = self.prefix + "_" + name
611 def parse(self, filename):
613 self.parser.ParseFile(file)