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)