def sources(self): # assume runtime instances are of the form: @Object(typ=..., idx=...) def obj_finder(val): m = re.match(r"@Object\(typ=(.+), idx=\d+\)", val) if m: return m.group(1) else: return None return util.rm_dup(util.rm_none(map(obj_finder, self._vals)))
def to_struct(cls): # make mappings from static fields to corresponding accessors def gen_s_flds_accessors(cls): s_flds = filter(op.attrgetter("is_static"), cls.flds) global _s_flds for fld in ifilterfalse(op.attrgetter("is_private"), s_flds): cname = fld.clazz.name fid = '.'.join([cname, fld.name]) fname = unicode(repr(fld)) logging.debug("{} => {}".format(fid, fname)) _s_flds[fid] = fname cname = util.sanitize_ty(cls.name) global _ty # if this is an interface, merge this into another family of classes # as long as classes that implement this interface are in the same family if cls.is_itf: # interface may have static constants gen_s_flds_accessors(cls) subss = util.flatten_classes(cls.subs, "subs") bases = util.rm_dup(map(lambda sub: find_base(sub), subss)) # filter out interfaces that extend other interfaces, e.g., Action base_clss, _ = util.partition(op.attrgetter("is_class"), bases) if not base_clss: logging.debug("no implementer of {}".format(cname)) elif len(base_clss) > 1: logging.debug("ambiguous inheritance of {}: {}".format(cname, base_clss)) else: # len(base_clss) == 1 base = base_clss[0] base_name = base.name logging.debug("{} => {}".format(cname, base_name)) _ty[cname] = base_name if cls.is_inner: # to handle inner interface w/ outer class name logging.debug("{} => {}".format(repr(cls), base_name)) _ty[unicode(repr(cls))] = base_name return '' # if this is the base class having subclasses, # make a virtual struct first if cls.subs: cls = to_v_struct(cls) cname = cls.name # cls can be modified above, thus generate static fields accessors here gen_s_flds_accessors(cls) # for unique class numbering, add an identity mapping if cname not in _ty: _ty[cname] = cname buf = cStringIO.StringIO() buf.write("struct " + cname + " {\n int hash;\n") # to avoid static fields, which will be bound to a class-representing package _, i_flds = util.partition(op.attrgetter("is_static"), cls.flds) buf.write('\n'.join(map(trans_fld, i_flds))) if len(i_flds) > 0: buf.write('\n') buf.write("}\n") return buf.getvalue()
def evt_sources(smpls): return util.rm_dup(map_attr(smpls, evt_sources))
def evt_kinds(smpls): return util.rm_dup(map_attr(smpls, evt_kinds))
def evt_sources(self): srcss = map(op.attrgetter("sources"), self.evts) return util.rm_dup(util.flatten(srcss))
def evt_kinds(self): kinds = map(op.attrgetter("kind"), self.evts) return util.rm_dup(kinds)
def to_struct(cls): # make mappings from static fields to corresponding accessors def gen_s_flds_accessors(cls): s_flds = filter(op.attrgetter("is_static"), cls.flds) global _s_flds for fld in ifilterfalse(op.attrgetter("is_private"), s_flds): cname = fld.clazz.name fid = '.'.join([cname, fld.name]) fname = unicode(repr(fld)) logging.debug("{} => {}".format(fid, fname)) _s_flds[fid] = fname cname = util.sanitize_ty(cls.name) global _ty # if this is an interface, merge this into another family of classes # as long as classes that implement this interface are in the same family if cls.is_itf: # interface may have static constants gen_s_flds_accessors(cls) subss = util.flatten_classes(cls.subs, "subs") bases = util.rm_dup(map(lambda sub: find_base(sub), subss)) # filter out interfaces that extend other interfaces, e.g., Action base_clss, _ = util.partition(op.attrgetter("is_class"), bases) if not base_clss: logging.debug("no implementer of {}".format(cname)) elif len(base_clss) > 1: logging.debug("ambiguous inheritance of {}: {}".format(cname, base_clss)) else: # len(base_clss) == 1 base = base_clss[0] base_name = base.name logging.debug("{} => {}".format(cname, base_name)) _ty[cname] = base_name if cls.is_inner: # to handle inner interface w/ outer class name logging.debug("{} => {}".format(repr(cls), base_name)) _ty[unicode(repr(cls))] = base_name return '' # if this is the base class having subclasses, # make a virtual struct first if cls.subs and not cls.is_aux: cls = to_v_struct(cls) cname = cls.name # cls can be modified above, thus generate static fields accessors here gen_s_flds_accessors(cls) # for unique class numbering, add an identity mapping if cname not in _ty: _ty[cname] = cname buf = cStringIO.StringIO() buf.write("struct " + cname + " {\n int hash;\n") # to avoid static fields, which will be bound to a class-representing package _, i_flds = util.partition(op.attrgetter("is_static"), cls.flds) buf.write('\n'.join(map(trans_fld, i_flds))) if len(i_flds) > 0: buf.write('\n') buf.write("}\n") return buf.getvalue()