def linkEnd(self): try: self.classes.remove(None) except: pass self.decls = [] self.decl_indexes = {} self.decl_bases = {} for decl in sorted(self.classes, key=lambda x: x.path): # print type(decl) # print decl cc = bc.RecordType(decl, isConstQualified=True) nc = bc.RecordType(decl, isConstQualified=False) cls = [ self.creator.getInterface(cc), self.creator.getInterface(nc), self.creator.getClass(nc), ] cls[1].addBase(cls[0]) cls[2].addBase(cls[1]) declared = filter(lambda x: x in self.declared_classes, self.listBases(decl)) for i in declared: cci = bc.RecordType(i, isConstQualified=True) nci = bc.RecordType(i, isConstQualified=False) cls[0].addBase(self.creator.getInterface(cci)) cls[1].addBase(self.creator.getInterface(nci)) self.decl_indexes[decl] = len(self.decls) self.decls.append(decl) self.decl_bases[decl] = _getAllBases(decl)
def __setRecord(self, d): decl, is_const = parseType(d) if decl is None: return # print d.name self.resolveInterfacePath( bc.LValueReferenceType(bc.RecordType(decl, isConstQualified=True))) self.resolveInterfacePath(decl) self.resolveClassPath(decl) self.__addClassDecl(decl)
def resolveInterfacePath(self, decl_or_type): decl, is_const = parseType(decl_or_type) klass, jp = self.creator.resolveInterfacePath(decl_or_type.pointeeType) klass = jclass.Class if not is_const: self.creator.getClass( bc.PointerType(bc.RecordType(decl, isConstQualified=True))) klass = PointerClass njp = jpath.JPath(jp.path + ('Ptr', )) self.classes[jp.path] = decl_or_type return klass, njp
def getVectorElem(cxx_type): elem_type, is_const, _ = isVector(cxx_type) # is_const = False # if isinstance(cxx_type, bc.LValueReferenceType): # is_const = is_const or cxx_type.isConstQualified # cxx_type = cxx_type.pointeeType # if isinstance(cxx_type, bc.ElaboratedType): # is_const = is_const or cxx_type.isConstQualified # cxx_type = cxx_type.namedType # is_const = is_const or cxx_type.isConstQualified t = bc.RecordType(elem_type.decl, isConstQualified=is_const) return t
def resolveClass(self, decl_or_type): postfix = '' if self.settings['lightweight_generics']: elem_type, isc, _ = isVector(decl_or_type) if isinstance(elem_type, bc.BuiltinType): print decl_or_type print elem_type raise Exception() t = self.creator.resolveClass( bc.RecordType(elem_type.decl, isConstQualified=isc)) postfix = '<%s*>' % t[1] return True, "NSArray%s" % postfix
def linkEnd(self): for i in self.classes: decl = self.classes[i].pointeeType.decl isConstQualified = self.classes[i].pointeeType.isConstQualified c = self.creator.getClass(self.classes[i]) intf = self.creator.getInterface(self.classes[i].pointeeType) intf2 = self.creator.getClass(self.classes[i].pointeeType) # print ">>", i, self.classes[i] fn = 'at' if isConstQualified: fn = 'cAt' f = PointerAtDecl( decl.name + "::" + fn, None, bc.LValueReferenceType( bc.RecordType(decl, isConstQualified=isConstQualified)), [bc.ParmVarDecl( "index", bc.BuiltinType("int"), )], decl, isConstQualified=isConstQualified) conv = self.creator.getFunctionConverter(f) c.addFunction(conv) fn = 'ref' if isConstQualified: fn = 'cref' f = getPointerFunctionDecl( decl.name + "::" + fn, None, bc.PointerType( bc.RecordType(decl, isConstQualified=isConstQualified)), [], decl) conv = self.creator.getFunctionConverter(f) # print intf, intf2, conv intf.addFunction(conv) intf2.addFunction(conv) if not isConstQualified: d = self.creator.getClass( bc.PointerType(bc.RecordType(decl, isConstQualified=True))) c.setBaseClass(d)
def getElemType(self): decl, is_const = parseType(self.cxx_type) return bc.RecordType(decl, isConstQualified=is_const)
def declare(self, decl): if not isinstance(decl, bc.RecordDecl): return False if decl.access != "public" and decl.access != "none": return False # print decl, "!" * 10 # decl.show() if decl.describedClassTemplate is not None: return False self.classes.add(decl) for i in self.listBases(decl): self.classes.add(i) cc = bc.RecordType(decl, isConstQualified=True) nc = bc.RecordType(decl, isConstQualified=False) cls = [ self.creator.getInterface(cc), self.creator.getInterface(nc), self.creator.getClass(nc), ] cls[2].is_valid = not decl.isAbstract cls[1].addBase(cls[0]) cls[2].addBase(cls[1]) # for i in self.listMethods(decl, const=True): for i in self.listAllMethods(decl, const=True): conv = self.creator.getFunctionConverter(i, decl) if not conv.isStatic(): cls[0].addFunction(conv) # cls[2].addFunction(conv) # for i in self.listMethods(decl, const=False): for i in self.listAllMethods(decl, const=False): conv = self.creator.getFunctionConverter(i, decl) if not conv.isStatic(): cls[1].addFunction(conv) # cls[2].addFunction(conv) if not decl.isAbstract: for i in self.listAllMethods(decl): conv = self.creator.getFunctionConverter(i, decl) cls[2].addFunction(conv) for i in self.listConstructors(decl): conv = self.creator.getFunctionConverter(i, decl) cls[2].addFunction(conv) if self.hasCopyConstructor(decl): f = CXXCopyDecl(decl.cname() + "::__copy__", None, bc.RecordType(decl), [], decl) conv = self.creator.getFunctionConverter(f, decl) cls[0].addFunction(conv) if not decl.isAbstract: cls[2].addFunction(conv) f = CXXAssignOperatorDecl( decl.cname() + "::__assign__", None, bc.BuiltinType("void"), [ bc.ParmVarDecl( "arg", bc.LValueReferenceType( bc.RecordType(decl, isConstQualified=True)), ), ], decl) conv = self.creator.getFunctionConverter(f, decl) cls[1].addFunction(conv) if not decl.isAbstract: cls[2].addFunction(conv) return True
def getReturnConverter(self): return CopyReturnConverter(self.creator, bc.RecordType(self.decl.parent), self)
def __init__(self, creator, cxx_type, func_conv): ty = bc.RecordType(cxx_type.decl) super(CopyReturnConverter, self).__init__(creator, ty, func_conv)
def __init__(self, creator, decl, func_conv): arg = bc.ParmVarDecl("_this", bc.LValueReferenceType(bc.RecordType(decl))) super(InstanceArgConverter, self).__init__(creator, arg, func_conv)
def linkEnd(self): l = sorted(self.classes, key=lambda x: x.path) # m = {} # for idx, decl in enumerate(l): # m[decl] = idx # self.class_indexes = m processed = [] tmp_map = {} while True: l = list(self.classes.difference(processed)) if not l: break # self.class_indexes = {} # for decl in l: # self.class_indexes[decl] = len(self.class_indexes) for decl in l: cc = bc.RecordType(decl, isConstQualified=True) nc = bc.RecordType(decl, isConstQualified=False) cc = self.creator.getClass(cc) nc = self.creator.getClass(nc) # print("=" * 80) # print(decl) # print(cc.funcs) # print(nc.funcs) if True or cc.funcs: ccp = self.creator.getClass('Api_' + cc.name, objc_class.ObjCProtocol) map(ccp.addFunction, cc.funcs) cc.addProtocol(ccp) else: ccp = None if True or nc.funcs: ncp = self.creator.getClass('Api_' + nc.name, objc_class.ObjCProtocol) map(ncp.addFunction, nc.funcs) nc.addProtocol(ncp) else: ncp = None tmp_map[decl] = cc, nc, ccp, ncp if decl.access != "public" and decl.access != "none": cc.setValid(False) nc.setValid(False) if not self.hasPublicDefaultConstructor(decl): cc.hasDelete(False) cc.addBase(self.creator.getBaseClass()) cc.setImpl(decl) nc.addBase(cc) nc.priority = 10 processed += l for decl in tmp_map: bases = self.listBases(decl) cc, nc, ccp, ncp = tmp_map[decl] for b in bases: if b in tmp_map: if tmp_map[b][2]: cc.addProtocol(tmp_map[b][2]) if tmp_map[b][3]: nc.addProtocol(tmp_map[b][3])
def declare(self, decl): # print("!" * 80) # print("field !!") # print(decl) # print(isinstance(decl, bc.RecordDecl)) if not isinstance(decl, bc.RecordDecl): return False # print("decl.describedClassTemplate: ", decl.describedClassTemplate) # TODO: bug fix,,, # if decl.describedClassTemplate is not None: # return False # print("access = ", decl.access) if decl.access != "public" and decl.access != "none": return False cc = bc.RecordType(decl, isConstQualified=True) nc = bc.RecordType(decl, isConstQualified=False) cc = self.creator.getClass(cc) nc = self.creator.getClass(nc) cc.setImpl(decl) nc.addBase(cc) nc.priority = 10 for i in self.listAllMethods(decl, const=True): conv = self.creator.getFunctionConverter(i) cc.addFunction(conv) for i in self.listAllMethods(decl, const=False): conv = self.creator.getFunctionConverter(i) nc.addFunction(conv) # print("=" * 80) # print("field !!") # print(decl) for field in self.listAllFields(decl): # print(field) ft = field.type if isinstance(ft, bc.SubstTemplateTypeParmType): ft = ft.sugar if (isinstance(base.eraseTypedef(ft), bc.BuiltinType) or isinstance(base.eraseTypedef(ft), bc.EnumType)): rt = ft else: rt = bc.LValueReferenceType(ft, isConstQualified=True) f = CXXGetterDecl("%s::get_%s" % (decl.path, field.name), None, rt, [], decl) f.field_name = field.name gconv = CXXGetterConverter(self.creator, f) cc.addFunction(gconv) if not (isinstance(base.eraseTypedef(ft), bc.BuiltinType) or isinstance(base.eraseTypedef(ft), bc.EnumType)): rt = bc.LValueReferenceType(ft, isConstQualified=False) f = CXXGetterDecl("%s::get_%s" % (decl.path, field.name), None, rt, [], decl) f.field_name = field.name gconv = CXXGetterConverter(self.creator, f) nc.addFunction(gconv) f = CXXSetterDecl("%s::set_%s" % (decl.path, field.name), None, bc.BuiltinType("void"), [ bc.ParmVarDecl("arg", ft), ], decl) f.field_name = field.name sconv = CXXSetterConverter(self.creator, f) nc.addFunction(sconv) t = gconv.return_converter.getObjCType() if not gconv.return_converter.isValid(): continue if gconv.isValid(): cc.addProperty( objc_class.Property(t, field.name, getter=gconv.getName(), other_attribs='assign, nonatomic')) gname = gconv.getName() else: gname = None if sconv.isValid(): # t = sconv.arg_converters[0].getObjCType() t = gconv.return_converter.getObjCType() nc.addProperty( objc_class.Property(t, field.name, getter=gname, setter=sconv.getName(), other_attribs='assign, nonatomic')) if False and self.hasCopyConstructor(decl): f = CXXCopyDecl(decl.path + "::__copy__", None, bc.RecordType(decl), [], decl) conv = self.creator.getFunctionConverter(f) cc.addFunction(conv) f = CXXAssignOperatorDecl( decl.path + "::__assign__", None, bc.BuiltinType("void"), [ bc.ParmVarDecl( "arg", bc.LValueReferenceType( bc.RecordType(decl, isConstQualified=True)), ), ], decl) conv = self.creator.getFunctionConverter(f) nc.addFunction(conv) return True
def dumpCCallPre(self, source): decl, is_const = parseType(self.cxx_type) ot = self.creator.resolveClass(bc.RecordType(decl))[1] source << ("%s* _ret_val = [%s alloc];" % (ot, ot))
# coding: utf-8 from blueboss import common as bc import plugin import string_plugin import jpath import jclass import builtin_reference_plugin STRING_REF_CLASS_PATH = jpath.JPath(("primitives", "StringRef")) STRING_TYPE = bc.TemplateSpecializationType() STRING_TYPE.sugar = bc.RecordType(bc.RecordDecl('std::basic_string')) STRING_TYPE.args = [ bc.TemplateArgument() ] STRING_TYPE.args[0].type = bc.BuiltinType("char") class StringRefGetDecl(bc.CXXMethodDecl): pass class StringRefSetDecl(bc.CXXMethodDecl): pass class InstanceArgConverter(builtin_reference_plugin.InstanceArgConverter): def getCTypeName(self): return "std::string"