{

CppcheckLibraryData::Container container;

container.id = xmlReader.attributes().value("id").toString();

container.inherits = xmlReader.attributes().value("inherits").toString();

container.startPattern = xmlReader.attributes().value("startPattern").toString();

container.endPattern = xmlReader.attributes().value("endPattern").toString();

container.opLessAllowed = xmlReader.attributes().value("opLessAllowed").toString();

container.itEndPattern = xmlReader.attributes().value("itEndPattern").toString();

QXmlStreamReader::TokenType type;

while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||

xmlReader.name().toString() != "container") {

if (type != QXmlStreamReader::StartElement)

continue;

const QString elementName = xmlReader.name().toString();

if (elementName == "type") {

container.type.templateParameter = xmlReader.attributes().value("templateParameter").toString();

container.type.string = xmlReader.attributes().value("string").toString();

} else if (elementName == "size" || elementName == "access" || elementName == "other") {

const QString indexOperator = xmlReader.attributes().value("indexOperator").toString();

if (elementName == "access" && indexOperator == "array-like")

container.access_arrayLike = true;

const QString templateParameter = xmlReader.attributes().value("templateParameter").toString();

if (elementName == "size" && !templateParameter.isEmpty())

container.size_templateParameter = templateParameter.toInt();

for (;;) {

type = xmlReader.readNext();

if (xmlReader.name().toString() == elementName)

break;

if (type != QXmlStreamReader::StartElement)

continue;

struct CppcheckLibraryData::Container::Function function;

function.name = xmlReader.attributes().value("name").toString();

function.action = xmlReader.attributes().value("action").toString();

function.yields = xmlReader.attributes().value("yields").toString();

if (elementName == "size")

container.sizeFunctions.append(function);

else if (elementName == "access")

container.accessFunctions.append(function);

else

container.otherFunctions.append(function);

}

} else {

unhandledElement(xmlReader);

}

}

return container;

{

CppcheckLibraryData::Define define;

define.name = xmlReader.attributes().value("name").toString();

define.value = xmlReader.attributes().value("value").toString();

return define;

{

CppcheckLibraryData::Function::Arg arg;

QString argnr = xmlReader.attributes().value("nr").toString();

if (argnr == "any")

arg.nr = CppcheckLibraryData::Function::Arg::ANY;

else if (argnr == "variadic")

arg.nr = CppcheckLibraryData::Function::Arg::VARIADIC;

else

arg.nr = argnr.toUInt();

arg.defaultValue = xmlReader.attributes().value("default").toString();

QXmlStreamReader::TokenType type;

while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||

xmlReader.name().toString() != "arg") {

if (type != QXmlStreamReader::StartElement)

continue;

const QString elementName = xmlReader.name().toString();

if (elementName == "not-bool")

arg.notbool = true;

else if (elementName == "not-null")

arg.notnull = true;

else if (elementName == "not-uninit")

arg.notuninit = true;

else if (elementName == "strz")

arg.strz = true;

else if (elementName == "formatstr")

arg.formatstr = true;

else if (elementName == "valid")

arg.valid = xmlReader.readElementText();

else if (elementName == "minsize") {

CppcheckLibraryData::Function::Arg::MinSize minsize;

minsize.type = xmlReader.attributes().value("type").toString();

minsize.arg = xmlReader.attributes().value("arg").toString();

minsize.arg2 = xmlReader.attributes().value("arg2").toString();

arg.minsizes.append(minsize);

} else if (elementName == "iterator") {

arg.iterator.container = xmlReader.attributes().value("container").toInt();

arg.iterator.type = xmlReader.attributes().value("type").toString();

} else {

unhandledElement(xmlReader);

}

}

return arg;

{

CppcheckLibraryData::Function function;

function.comments = comments;

function.name = xmlReader.attributes().value("name").toString();

QXmlStreamReader::TokenType type;

while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||

xmlReader.name().toString() != "function") {

if (type != QXmlStreamReader::StartElement)

continue;

const QString elementName = xmlReader.name().toString();

if (elementName == "noreturn")

function.noreturn = (xmlReader.readElementText() == "true") ? CppcheckLibraryData::Function::True : CppcheckLibraryData::Function::False;

else if (elementName == "pure")

function.gccPure = true;

else if (elementName == "const")

function.gccConst = true;

else if (elementName == "leak-ignore")

function.leakignore = true;

else if (elementName == "use-retval")

function.useretval = true;

else if (elementName == "returnValue") {

const QString container = xmlReader.attributes().value("container").toString();

function.returnValue.container = container.isNull() ? -1 : container.toInt();

function.returnValue.type = xmlReader.attributes().value("type").toString();

function.returnValue.value = xmlReader.readElementText();

} else if (elementName == "formatstr") {

function.formatstr.scan = xmlReader.attributes().value("scan").toString();

function.formatstr.secure = xmlReader.attributes().value("secure").toString();

} else if (elementName == "arg")

function.args.append(loadFunctionArg(xmlReader));

else if (elementName == "warn") {

function.warn.severity = xmlReader.attributes().value("severity").toString();

function.warn.cstd = xmlReader.attributes().value("cstd").toString();

function.warn.reason = xmlReader.attributes().value("reason").toString();

function.warn.alternatives = xmlReader.attributes().value("alternatives").toString();

function.warn.msg = xmlReader.readElementText();

} else {

unhandledElement(xmlReader);

}

}

return function;

{

CppcheckLibraryData::MemoryResource memoryresource;

memoryresource.type = xmlReader.name().toString();

QXmlStreamReader::TokenType type;

while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||

xmlReader.name().toString() != memoryresource.type) {

if (type != QXmlStreamReader::StartElement)

continue;

const QString elementName = xmlReader.name().toString();

if (elementName == "alloc") {

CppcheckLibraryData::MemoryResource::Alloc alloc;

alloc.init = (xmlReader.attributes().value("init").toString() == "true");

alloc.name = xmlReader.readElementText();

memoryresource.alloc.append(alloc);

} else if (elementName == "dealloc")

memoryresource.dealloc.append(xmlReader.readElementText());

else if (elementName == "use")

memoryresource.use.append(xmlReader.readElementText());

else

unhandledElement(xmlReader);

}

return memoryresource;

{

CppcheckLibraryData::PodType podtype;

podtype.name = xmlReader.attributes().value("name").toString();

podtype.size = xmlReader.attributes().value("size").toString();

podtype.sign = xmlReader.attributes().value("sign").toString();

return podtype;

{

clear();

QString comments;

QXmlStreamReader xmlReader(&file);

while (!xmlReader.atEnd()) {

const QXmlStreamReader::TokenType t = xmlReader.readNext();

switch (t) {

case QXmlStreamReader::Comment:

if (!comments.isEmpty())

comments += "\n";

comments += xmlReader.text().toString();

break;

case QXmlStreamReader::StartElement:

try {

const QString elementName(xmlReader.name().toString());

if (elementName == "def")

;

else if (elementName == "container")

containers.append(loadContainer(xmlReader));

else if (elementName == "define")

defines.append(loadDefine(xmlReader));

else if (elementName == "function")

functions.append(loadFunction(xmlReader, comments));

else if (elementName == "memory" || elementName == "resource")

memoryresource.append(loadMemoryResource(xmlReader));

else if (elementName == "podtype")

podtypes.append(loadPodType(xmlReader));

else

unhandledElement(xmlReader);

} catch (std::runtime_error &e) {

return e.what();

}

comments.clear();

break;

default:

break;

}

}

return QString();

{

if (functions.isEmpty() && extra < 0)

return;

xmlWriter.writeStartElement(name);

if (extra >= 0) {

if (name == "access")

xmlWriter.writeAttribute("indexOperator", "array-like");

else if (name == "size")

xmlWriter.writeAttribute("templateParameter", QString::number(extra));

}

foreach (const CppcheckLibraryData::Container::Function &function, functions) {

xmlWriter.writeStartElement("function");

xmlWriter.writeAttribute("name", function.name);

if (!function.action.isEmpty())

xmlWriter.writeAttribute("action", function.action);

if (!function.yields.isEmpty())

xmlWriter.writeAttribute("yields", function.yields);

xmlWriter.writeEndElement();

}

xmlWriter.writeEndElement();

{

xmlWriter.writeStartElement("container");

xmlWriter.writeAttribute("id", container.id);

if (!container.startPattern.isEmpty())

xmlWriter.writeAttribute("startPattern", container.startPattern);

if (!container.endPattern.isNull())

xmlWriter.writeAttribute("endPattern", container.endPattern);

if (!container.inherits.isEmpty())

xmlWriter.writeAttribute("inherits", container.inherits);

if (!container.opLessAllowed.isEmpty())

xmlWriter.writeAttribute("opLessAllowed", container.opLessAllowed);

if (!container.itEndPattern.isEmpty())

xmlWriter.writeAttribute("itEndPattern", container.itEndPattern);

if (!container.type.templateParameter.isEmpty() || !container.type.string.isEmpty()) {

xmlWriter.writeStartElement("type");

if (!container.type.templateParameter.isEmpty())

xmlWriter.writeAttribute("templateParameter", container.type.templateParameter);

if (!container.type.string.isEmpty())

xmlWriter.writeAttribute("string", container.type.string);

xmlWriter.writeEndElement();

}

writeContainerFunctions(xmlWriter, "size", container.size_templateParameter, container.sizeFunctions);

writeContainerFunctions(xmlWriter, "access", container.access_arrayLike?1:-1, container.accessFunctions);

writeContainerFunctions(xmlWriter, "other", -1, container.otherFunctions);

xmlWriter.writeEndElement();

{

QString comments = function.comments;

while (comments.startsWith("\n"))

comments = comments.mid(1);

while (comments.endsWith("\n"))

comments.chop(1);

foreach (const QString &comment, comments.split('\n')) {

if (comment.length() >= 1)

xmlWriter.writeComment(comment);

}

xmlWriter.writeStartElement("function");

xmlWriter.writeAttribute("name", function.name);

if (function.useretval)

xmlWriter.writeEmptyElement("use-retval");

if (function.gccConst)

xmlWriter.writeEmptyElement("const");

if (function.gccPure)

xmlWriter.writeEmptyElement("pure");

if (!function.returnValue.empty()) {

xmlWriter.writeStartElement("returnValue");

if (!function.returnValue.type.isNull())

xmlWriter.writeAttribute("type", function.returnValue.type);

if (function.returnValue.container >= 0)

xmlWriter.writeAttribute("container", QString::number(function.returnValue.container));

if (!function.returnValue.value.isNull())

xmlWriter.writeCharacters(function.returnValue.value);

xmlWriter.writeEndElement();

}

if (function.noreturn != CppcheckLibraryData::Function::Unknown)

xmlWriter.writeTextElement("noreturn", (function.noreturn == CppcheckLibraryData::Function::True) ? "true" : "false");

if (function.leakignore)

xmlWriter.writeEmptyElement("leak-ignore");

// Argument info..

foreach (const CppcheckLibraryData::Function::Arg &arg, function.args) {

if (arg.formatstr) {

xmlWriter.writeStartElement("formatstr");

if (!function.formatstr.scan.isNull())

xmlWriter.writeAttribute("scan", function.formatstr.scan);

if (!function.formatstr.secure.isNull())

xmlWriter.writeAttribute("secure", function.formatstr.secure);

xmlWriter.writeEndElement();

}

xmlWriter.writeStartElement("arg");

if (arg.nr == CppcheckLibraryData::Function::Arg::ANY)

xmlWriter.writeAttribute("nr", "any");

else if (arg.nr == CppcheckLibraryData::Function::Arg::VARIADIC)

xmlWriter.writeAttribute("nr", "variadic");

else

xmlWriter.writeAttribute("nr", QString::number(arg.nr));

if (!arg.defaultValue.isNull())

xmlWriter.writeAttribute("default", arg.defaultValue);

if (arg.formatstr)

xmlWriter.writeEmptyElement("formatstr");

if (arg.notnull)

xmlWriter.writeEmptyElement("not-null");

if (arg.notuninit)

xmlWriter.writeEmptyElement("not-uninit");

if (arg.notbool)

xmlWriter.writeEmptyElement("not-bool");

if (arg.strz)

xmlWriter.writeEmptyElement("strz");

if (!arg.valid.isEmpty())

xmlWriter.writeTextElement("valid",arg.valid);

foreach (const CppcheckLibraryData::Function::Arg::MinSize &minsize, arg.minsizes) {

xmlWriter.writeStartElement("minsize");

xmlWriter.writeAttribute("type", minsize.type);

xmlWriter.writeAttribute("arg", minsize.arg);

if (!minsize.arg2.isEmpty())

xmlWriter.writeAttribute("arg2", minsize.arg2);

xmlWriter.writeEndElement();

}

if (arg.iterator.container >= 0 || !arg.iterator.type.isNull()) {

xmlWriter.writeStartElement("iterator");

if (arg.iterator.container >= 0)

xmlWriter.writeAttribute("container", QString::number(arg.iterator.container));

if (!arg.iterator.type.isNull())

xmlWriter.writeAttribute("type", arg.iterator.type);

xmlWriter.writeEndElement();

}

xmlWriter.writeEndElement();

}

if (!function.warn.isEmpty()) {

xmlWriter.writeStartElement("warn");

if (!function.warn.severity.isEmpty())

xmlWriter.writeAttribute("severity", function.warn.severity);

if (!function.warn.cstd.isEmpty())

xmlWriter.writeAttribute("cstd", function.warn.cstd);

if (!function.warn.alternatives.isEmpty())

xmlWriter.writeAttribute("alternatives", function.warn.alternatives);

if (!function.warn.reason.isEmpty())

xmlWriter.writeAttribute("reason", function.warn.reason);

if (!function.warn.msg.isEmpty())

xmlWriter.writeCharacters(function.warn.msg);

xmlWriter.writeEndElement();

}

xmlWriter.writeEndElement();

{

xmlWriter.writeStartElement(mr.type);

foreach (const CppcheckLibraryData::MemoryResource::Alloc &alloc, mr.alloc) {

xmlWriter.writeStartElement("alloc");

xmlWriter.writeAttribute("init", alloc.init ? "true" : "false");

xmlWriter.writeCharacters(alloc.name);

xmlWriter.writeEndElement();

}

foreach (const QString &dealloc, mr.dealloc) {

xmlWriter.writeTextElement("dealloc", dealloc);

}

foreach (const QString &use, mr.use) {

xmlWriter.writeTextElement("use", use);

}

xmlWriter.writeEndElement();

{

QString outputString;

QXmlStreamWriter xmlWriter(&outputString);

xmlWriter.setAutoFormatting(true);

xmlWriter.setAutoFormattingIndent(2);

xmlWriter.writeStartDocument("1.0");

xmlWriter.writeStartElement("def");

xmlWriter.writeAttribute("format","2");

foreach (const Define &define, defines) {

xmlWriter.writeStartElement("define");

xmlWriter.writeAttribute("name", define.name);

xmlWriter.writeAttribute("value", define.value);

xmlWriter.writeEndElement();

}

foreach (const Function &function, functions) {

writeFunction(xmlWriter, function);

}

foreach (const MemoryResource &mr, memoryresource) {

writeMemoryResource(xmlWriter, mr);

}

foreach (const Container &container, containers) {

writeContainer(xmlWriter, container);

}

foreach (const PodType &podtype, podtypes) {

xmlWriter.writeStartElement("podtype");

xmlWriter.writeAttribute("name", podtype.name);

if (!podtype.sign.isEmpty())

xmlWriter.writeAttribute("sign", podtype.sign);

if (!podtype.size.isEmpty())

xmlWriter.writeAttribute("size", podtype.size);

xmlWriter.writeEndElement();

}

xmlWriter.writeEndElement();

return outputString;