def getFunction(elem): syms = [] name = getters.getName(elem) include = getters.getLocation(elem) params = getters.getParamDesc(elem, getters.getParams(elem)) briefDesc = getters.getBriefDesc(elem) detailedDesc = getters.getFunctionDetailedDesc(elem) returnType = getters.getType(elem) exceptions = getters.getExceptions(elem) returnDesc = getters.getReturnDesc(elem) returnValues = getters.getRetvals(elem) funcProto = buildPrototype(returnType + " " + name + "(", briefDesc) for param in params: proto = param.type + " " + param.name funcProto.prototype += proto + ", " funcProto.addParameter( buildParameter(prototype=proto, description=param.desc)) for ex in exceptions: funcProto.addException( buildException(linkedSymbol=ex.typename, description=ex.description)) if len(params) != 0: funcProto.prototype = funcProto.prototype[:-2] funcProto.prototype += ")" funcProto.addParameter( buildParameter(prototype="return", description=returnDesc)) syms.append( buildFunction(path=name, prototypeObj=funcProto, importString=include)) return syms
def getEnum(elem): syms = [] name = getters.getName(elem) include = getters.getLocation(elem) params = getters.getEnumParams(elem) briefDesc = getters.getBriefDesc(elem) detailedDesc = getters.getDetailedDesc(elem) enumProto = buildPrototype("enum " + name + " { ", briefDesc) for param in params: if param.initializer != "": proto = param.name + param.initializer else: proto = param.name enumProto.prototype += proto + ", " enumProto.addParameter( buildParameter(prototype=proto, description=param.desc)) if len(params) != 0: enumProto.prototype = enumProto.prototype[:-2] enumProto.prototype += " }" enumSym = buildVariable(path=name, prototypeObj=enumProto, importString=include) syms.append(enumSym) return syms
def buildFunctionPrototype(protoPrefix, protoSuffix, name, returnType, briefDesc, detailedDesc, parameters, returnDesc, exceptions): pObj = GenericPrototype() funcProto = returnType + " " + name + "(" if (len(parameters) > 0): for par in parameters: proto = par.type + " " + par.name if (par.value != None and len(par.value) > 0): proto = proto + " = " + par.value funcProto = funcProto + proto + ", " symref = resolveReference(par.ref) if (symref != None): pObj.addParameter( buildParameter(prototype=proto, description=par.desc, linkedSymbol=symref.path)) else: pObj.addParameter( buildParameter(prototype=proto, description=par.desc)) funcProto = funcProto[:-2] if (len(returnDesc) > 0): pObj.addParameter( buildParameter(prototype="return", description=returnDesc)) funcProto = funcProto + ")" funcProto = protoPrefix + " " + funcProto + protoSuffix pObj.prototype = funcProto pObj.description = briefDesc if (len(detailedDesc) > 0): pObj.description = detailedDesc if (len(exceptions) > 0): for ex in exceptions: e = None if (ex.reference != None): e = buildException(linkedSymbol=resolveReference( ex.reference).path, description=ex.description) else: e = buildException(linkedSymbol="AUTOGEN:" + ex.typename, description=ex.description) pObj.addException(e) return (pObj)
def buildDefinePrototype(name, briefDesc, detailedDesc, parameters): pObj = GenericPrototype() funcProto = "#define " + name + "(" if (len(parameters) > 0): for par in parameters: funcProto = funcProto + par.name + ", " pObj.addParameter( buildParameter(prototype=par.name, description=par.desc)) funcProto = funcProto[:-2] funcProto = funcProto + ")" pObj.prototype = funcProto pObj.description = briefDesc if (len(detailedDesc) > 0): pObj.description = detailedDesc return (pObj)
def parseClass(root): #Obtain generic information about the class cpdef = root.find("compounddef") name = cpdef.find("compoundname").text path = name.replace("::", "/") classProto = cpdef.get("prot") + " " importStr = cpdef.find("location").get("file") isAbstract = cpdef.get("abstract") if (isAbstract == "yes"): classProto = classProto + "abstract " classProto = classProto + "class " + name briefDesc = getters.getBriefDesc(cpdef) detailedDesc = getters.getDetailedDesc(cpdef) description = briefDesc if (len(detailedDesc) > 0): description = detailedDesc templatePars = [] tlist = cpdef.find("templateparamlist") if (tlist != None): for elem in tlist.iter('param'): v = variableClass() v.type = elem.find("type") if (elem.find("declname") == None): #Found bug in Doxygen logWarning( "A terrible error has occured in Doxygen: template is corrupted, attempting restore..." ) txt = v.type.text vals = txt.split(" ") if (len(vals) < 2): logError("Unable to restore corrupted template!") continue v.type = vals[0] v.name = vals[1] logInfo("Successfully restored corrupted template!") else: if (v.type.find("ref") != None): v.ref = v.type.find("ref").get("refid") if (resolveReference(v.ref) != None): v.ref = resolveReference(v.ref).path v.type = v.type.find("ref").text else: v.type = v.type.text v.name = elem.find("declname").text if (elem.find("defval") != None): v.value = elem.find("defval").text templatePars.append(v) if (len(templatePars) > 0): prefix = "template <" for v in templatePars: prefix = prefix + v.type + " " + v.name if (v.value != None and len(v.value) > 0): prefix = prefix + " = " + v.value prefix = prefix + ", " prefix = prefix[:-2] prefix = prefix + ">" classProto = prefix + classProto templatePars = getters.getParamDesc(cpdef, templatePars) #Build a symbol for the class proto = buildPrototype(prototype=classProto, description=description) for v in templatePars: proto.addParameter( buildParameter(prototype=v.type + " " + v.name, description=v.desc)) cl = buildClass(path=path, prototypeObj=proto, importString=importStr) syms = [] for elem in root.iter('memberdef'): kind = elem.get('kind') pp3b = path + "/" + elem.find("name").text cl.addMember(pp3b) syms1 = [] if (kind in kindTable): syms1 = kindTable[kind](elem) for s in syms1: s.typename = "member " + s.typename s.path = pp3b syms.append(s) for elem in root.iter('innerclass'): pp3b = elem.text.replace("::", "/") cl.addMember(pp3b) syms.append(cl) return (syms)