{

std::vector<std::string> ret;

while (const char *p = std::strchr(names,',')) {

ret.emplace_back(names, p-names);

names = p + 1;

}

ret.emplace_back(names);

return ret;

{

std::istringstream istr(valid + ',');

tokenList.createTokens(istr);

for (Token *tok = tokenList.front(); tok; tok = tok->next()) {

if (Token::Match(tok,"- %num%")) {

tok->str("-" + tok->strAt(1));

tok->deleteNext();

}

}

{

if (std::strchr(path,',') != nullptr) {

std::string p(path);

for (;;) {

const std::string::size_type pos = p.find(',');

if (pos == std::string::npos)

break;

const Error &e = load(exename, p.substr(0,pos).c_str());

if (e.errorcode != ErrorCode::OK)

return e;

p = p.substr(pos+1);

}

if (!p.empty())

return load(exename, p.c_str());

return Error();

}

std::string absolute_path;

// open file..

tinyxml2::XMLDocument doc;

tinyxml2::XMLError error = doc.LoadFile(path);

if (error == tinyxml2::XML_ERROR_FILE_READ_ERROR && Path::getFilenameExtension(path).empty())

// Reading file failed, try again...

error = tinyxml2::XML_ERROR_FILE_NOT_FOUND;

if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND) {

// failed to open file.. is there no extension?

std::string fullfilename(path);

if (Path::getFilenameExtension(fullfilename).empty()) {

fullfilename += ".cfg";

error = doc.LoadFile(fullfilename.c_str());

if (error != tinyxml2::XML_ERROR_FILE_NOT_FOUND)

absolute_path = Path::getAbsoluteFilePath(fullfilename);

}

std::list<std::string> cfgfolders;

#ifdef FILESDIR

cfgfolders.emplace_back(FILESDIR "/cfg");

#endif

if (exename) {

const std::string exepath(Path::fromNativeSeparators(Path::getPathFromFilename(exename)));

cfgfolders.push_back(exepath + "cfg");

cfgfolders.push_back(exepath);

}

while (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND && !cfgfolders.empty()) {

const std::string cfgfolder(cfgfolders.back());

cfgfolders.pop_back();

const char *sep = (!cfgfolder.empty() && endsWith(cfgfolder,'/') ? "" : "/");

const std::string filename(cfgfolder + sep + fullfilename);

error = doc.LoadFile(filename.c_str());

if (error != tinyxml2::XML_ERROR_FILE_NOT_FOUND)

absolute_path = Path::getAbsoluteFilePath(filename);

}

} else

absolute_path = Path::getAbsoluteFilePath(path);

if (error == tinyxml2::XML_SUCCESS) {

if (mFiles.find(absolute_path) == mFiles.end()) {

Error err = load(doc);

if (err.errorcode == ErrorCode::OK)

mFiles.insert(absolute_path);

return err;

}

return Error(ErrorCode::OK); // ignore duplicates

}

if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND)

return Error(ErrorCode::FILE_NOT_FOUND);

else {

doc.PrintError();

return Error(ErrorCode::BAD_XML);

}

{

tinyxml2::XMLDocument doc;

return (tinyxml2::XML_SUCCESS == doc.Parse(xmldata, len)) && (load(doc).errorcode == ErrorCode::OK);

{

const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();

if (rootnode == nullptr) {

doc.PrintError();

return Error(ErrorCode::BAD_XML);

}

if (strcmp(rootnode->Name(),"def") != 0)

return Error(ErrorCode::UNSUPPORTED_FORMAT, rootnode->Name());

int format = rootnode->IntAttribute("format", 1); // Assume format version 1 if nothing else is specified (very old .cfg files had no 'format' attribute)

if (format > 2 || format <= 0)

return Error(ErrorCode::UNSUPPORTED_FORMAT);

std::set<std::string> unknown_elements;

for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {

const std::string nodename = node->Name();

if (nodename == "memory" || nodename == "resource") {

// get allocationId to use..

int allocationId = 0;

for (const tinyxml2::XMLElement *memorynode = node->FirstChildElement(); memorynode; memorynode = memorynode->NextSiblingElement()) {

if (strcmp(memorynode->Name(),"dealloc")==0) {

const std::map<std::string, AllocFunc>::const_iterator it = mDealloc.find(memorynode->GetText());

if (it != mDealloc.end()) {

allocationId = it->second.groupId;

break;

}

}

}

if (allocationId == 0) {

if (nodename == "memory")

while (!ismemory(++mAllocId));

else

while (!isresource(++mAllocId));

allocationId = mAllocId;

}

// add alloc/dealloc/use functions..

for (const tinyxml2::XMLElement *memorynode = node->FirstChildElement(); memorynode; memorynode = memorynode->NextSiblingElement()) {

const std::string memorynodename = memorynode->Name();

if (memorynodename == "alloc" || memorynodename == "realloc") {

AllocFunc temp = {0};

temp.groupId = allocationId;

temp.initData = memorynode->BoolAttribute("init", true);

temp.arg = memorynode->IntAttribute("arg", -1);

const char *bufferSize = memorynode->Attribute("buffer-size");

if (!bufferSize)

temp.bufferSize = AllocFunc::BufferSize::none;

else {

if (std::strncmp(bufferSize, "malloc", 6) == 0)

temp.bufferSize = AllocFunc::BufferSize::malloc;

else if (std::strncmp(bufferSize, "calloc", 6) == 0)

temp.bufferSize = AllocFunc::BufferSize::calloc;

else if (std::strncmp(bufferSize, "strdup", 6) == 0)

temp.bufferSize = AllocFunc::BufferSize::strdup;

else

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, bufferSize);

temp.bufferSizeArg1 = 1;

temp.bufferSizeArg2 = 2;

if (bufferSize[6] == 0) {

// use default values

} else if (bufferSize[6] == ':' && bufferSize[7] >= '1' && bufferSize[7] <= '5') {

temp.bufferSizeArg1 = bufferSize[7] - '0';

if (bufferSize[8] == ',' && bufferSize[9] >= '1' && bufferSize[9] <= '5')

temp.bufferSizeArg2 = bufferSize[9] - '0';

} else

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, bufferSize);

}

if (memorynodename == "realloc")

temp.reallocArg = memorynode->IntAttribute("realloc-arg", 1);

if (memorynodename != "realloc")

mAlloc[memorynode->GetText()] = temp;

else

mRealloc[memorynode->GetText()] = temp;

} else if (memorynodename == "dealloc") {

AllocFunc temp = {0};

temp.groupId = allocationId;

temp.arg = memorynode->IntAttribute("arg", 1);

mDealloc[memorynode->GetText()] = temp;

} else if (memorynodename == "use")

functions[memorynode->GetText()].use = true;

else

unknown_elements.insert(memorynodename);

}

}

else if (nodename == "define") {

const char *name = node->Attribute("name");

if (name == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

const char *value = node->Attribute("value");

if (value == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "value");

defines.push_back(std::string(name) +

" " +

value);

}

else if (nodename == "function") {

const char *name = node->Attribute("name");

if (name == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

for (const std::string &s : getnames(name)) {

const Error &err = loadFunction(node, s, unknown_elements);

if (err.errorcode != ErrorCode::OK)

return err;

}

}

else if (nodename == "reflection") {

for (const tinyxml2::XMLElement *reflectionnode = node->FirstChildElement(); reflectionnode; reflectionnode = reflectionnode->NextSiblingElement()) {

if (strcmp(reflectionnode->Name(), "call") != 0) {

unknown_elements.insert(reflectionnode->Name());

continue;

}

const char * const argString = reflectionnode->Attribute("arg");

if (!argString)

return Error(ErrorCode::MISSING_ATTRIBUTE, "arg");

mReflection[reflectionnode->GetText()] = atoi(argString);

}

}

else if (nodename == "markup") {

const char * const extension = node->Attribute("ext");

if (!extension)

return Error(ErrorCode::MISSING_ATTRIBUTE, "ext");

mMarkupExtensions.insert(extension);

mReportErrors[extension] = (node->Attribute("reporterrors", "true") != nullptr);

mProcessAfterCode[extension] = (node->Attribute("aftercode", "true") != nullptr);

for (const tinyxml2::XMLElement *markupnode = node->FirstChildElement(); markupnode; markupnode = markupnode->NextSiblingElement()) {

const std::string markupnodename = markupnode->Name();

if (markupnodename == "keywords") {

for (const tinyxml2::XMLElement *librarynode = markupnode->FirstChildElement(); librarynode; librarynode = librarynode->NextSiblingElement()) {

if (strcmp(librarynode->Name(), "keyword") == 0) {

const char* nodeName = librarynode->Attribute("name");

if (nodeName == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

mKeywords[extension].insert(nodeName);

} else

unknown_elements.insert(librarynode->Name());

}

}

else if (markupnodename == "exported") {

for (const tinyxml2::XMLElement *exporter = markupnode->FirstChildElement(); exporter; exporter = exporter->NextSiblingElement()) {

if (strcmp(exporter->Name(), "exporter") != 0) {

unknown_elements.insert(exporter->Name());

continue;

}

const char * const prefix = exporter->Attribute("prefix");

if (!prefix)

return Error(ErrorCode::MISSING_ATTRIBUTE, "prefix");

for (const tinyxml2::XMLElement *e = exporter->FirstChildElement(); e; e = e->NextSiblingElement()) {

const std::string ename = e->Name();

if (ename == "prefix")

mExporters[prefix].addPrefix(e->GetText());

else if (ename == "suffix")

mExporters[prefix].addSuffix(e->GetText());

else

unknown_elements.insert(ename);

}

}

}

else if (markupnodename == "imported") {

for (const tinyxml2::XMLElement *librarynode = markupnode->FirstChildElement(); librarynode; librarynode = librarynode->NextSiblingElement()) {

if (strcmp(librarynode->Name(), "importer") == 0)

mImporters[extension].insert(librarynode->GetText());

else

unknown_elements.insert(librarynode->Name());

}

}

else if (markupnodename == "codeblocks") {

for (const tinyxml2::XMLElement *blocknode = markupnode->FirstChildElement(); blocknode; blocknode = blocknode->NextSiblingElement()) {

const std::string blocknodename = blocknode->Name();

if (blocknodename == "block") {

const char * blockName = blocknode->Attribute("name");

if (blockName)

mExecutableBlocks[extension].addBlock(blockName);

} else if (blocknodename == "structure") {

const char * start = blocknode->Attribute("start");

if (start)

mExecutableBlocks[extension].setStart(start);

const char * end = blocknode->Attribute("end");

if (end)

mExecutableBlocks[extension].setEnd(end);

const char * offset = blocknode->Attribute("offset");

if (offset)

mExecutableBlocks[extension].setOffset(atoi(offset));

}

else

unknown_elements.insert(blocknodename);

}

}

else

unknown_elements.insert(markupnodename);

}

}

else if (nodename == "container") {

const char* const id = node->Attribute("id");

if (!id)

return Error(ErrorCode::MISSING_ATTRIBUTE, "id");

Container& container = containers[id];

const char* const inherits = node->Attribute("inherits");

if (inherits) {

const std::map<std::string, Container>::const_iterator i = containers.find(inherits);

if (i != containers.end())

container = i->second; // Take values from parent and overwrite them if necessary

else

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, inherits);

}

const char* const startPattern = node->Attribute("startPattern");

if (startPattern) {

container.startPattern = startPattern;

container.startPattern2 = container.startPattern + " !!::";

}

const char* const endPattern = node->Attribute("endPattern");

if (endPattern)

container.endPattern = endPattern;

const char* const itEndPattern = node->Attribute("itEndPattern");

if (itEndPattern)

container.itEndPattern = itEndPattern;

const char* const opLessAllowed = node->Attribute("opLessAllowed");

if (opLessAllowed)

container.opLessAllowed = std::string(opLessAllowed) == "true";

const char* const hasInitializerListConstructor = node->Attribute("hasInitializerListConstructor");

if (hasInitializerListConstructor)

container.hasInitializerListConstructor = std::string(hasInitializerListConstructor) == "true";

const char* const view = node->Attribute("view");

if (view)

container.view = std::string(view) == "true";

for (const tinyxml2::XMLElement *containerNode = node->FirstChildElement(); containerNode; containerNode = containerNode->NextSiblingElement()) {

const std::string containerNodeName = containerNode->Name();

if (containerNodeName == "size" || containerNodeName == "access" || containerNodeName == "other") {

for (const tinyxml2::XMLElement *functionNode = containerNode->FirstChildElement(); functionNode; functionNode = functionNode->NextSiblingElement()) {

if (std::string(functionNode->Name()) != "function") {

unknown_elements.insert(functionNode->Name());

continue;

}

const char* const functionName = functionNode->Attribute("name");

if (!functionName)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

const char* const action_ptr = functionNode->Attribute("action");

Container::Action action = Container::Action::NO_ACTION;

if (action_ptr) {

std::string actionName = action_ptr;

action = Container::actionFrom(actionName);

if (action == Container::Action::NO_ACTION)

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, actionName);

}

const char* const yield_ptr = functionNode->Attribute("yields");

Container::Yield yield = Container::Yield::NO_YIELD;

if (yield_ptr) {

std::string yieldName = yield_ptr;

yield = Container::yieldFrom(yieldName);

if (yield == Container::Yield::NO_YIELD)

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, yieldName);

}

container.functions[functionName].action = action;

container.functions[functionName].yield = yield;

}

if (containerNodeName == "size") {

const char* const templateArg = containerNode->Attribute("templateParameter");

if (templateArg)

container.size_templateArgNo = atoi(templateArg);

} else if (containerNodeName == "access") {

const char* const indexArg = containerNode->Attribute("indexOperator");

if (indexArg)

container.arrayLike_indexOp = std::string(indexArg) == "array-like";

}

} else if (containerNodeName == "type") {

const char* const templateArg = containerNode->Attribute("templateParameter");

if (templateArg)

container.type_templateArgNo = atoi(templateArg);

const char* const string = containerNode->Attribute("string");

if (string)

container.stdStringLike = std::string(string) == "std-like";

const char* const associative = containerNode->Attribute("associative");

if (associative)

container.stdAssociativeLike = std::string(associative) == "std-like";

const char* const unstable = containerNode->Attribute("unstable");

if (unstable) {

std::string unstableType = unstable;

if (unstableType.find("erase") != std::string::npos)

container.unstableErase = true;

if (unstableType.find("insert") != std::string::npos)

container.unstableInsert = true;

}

} else if (containerNodeName == "rangeItemRecordType") {

for (const tinyxml2::XMLElement* memberNode = node->FirstChildElement(); memberNode; memberNode = memberNode->NextSiblingElement()) {

const char *memberName = memberNode->Attribute("name");

const char *memberTemplateParameter = memberNode->Attribute("templateParameter");

struct Container::RangeItemRecordTypeItem member;

member.name = memberName ? memberName : "";

member.templateParameter = memberTemplateParameter ? std::atoi(memberTemplateParameter) : -1;

container.rangeItemRecordType.emplace_back(member);

}

} else

unknown_elements.insert(containerNodeName);

}

}

else if (nodename == "smart-pointer") {

const char *className = node->Attribute("class-name");

if (!className)

return Error(ErrorCode::MISSING_ATTRIBUTE, "class-name");

SmartPointer& smartPointer = smartPointers[className];

smartPointer.name = className;

for (const tinyxml2::XMLElement* smartPointerNode = node->FirstChildElement(); smartPointerNode;

smartPointerNode = smartPointerNode->NextSiblingElement()) {

const std::string smartPointerNodeName = smartPointerNode->Name();

if (smartPointerNodeName == "unique")

smartPointer.unique = true;

}

}

else if (nodename == "type-checks") {

for (const tinyxml2::XMLElement *checkNode = node->FirstChildElement(); checkNode; checkNode = checkNode->NextSiblingElement()) {

const std::string &checkName = checkNode->Name();

for (const tinyxml2::XMLElement *checkTypeNode = checkNode->FirstChildElement(); checkTypeNode; checkTypeNode = checkTypeNode->NextSiblingElement()) {

const std::string checkTypeName = checkTypeNode->Name();

const char *typeName = checkTypeNode->GetText();

if (!typeName)

continue;

if (checkTypeName == "check")

mTypeChecks[std::pair<std::string,std::string>(checkName, typeName)] = TypeCheck::check;

else if (checkTypeName == "suppress")

mTypeChecks[std::pair<std::string,std::string>(checkName, typeName)] = TypeCheck::suppress;

}

}

}

else if (nodename == "podtype") {

const char * const name = node->Attribute("name");

if (!name)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

PodType podType = {0};

podType.stdtype = PodType::Type::NO;

const char * const stdtype = node->Attribute("stdtype");

if (stdtype) {

if (std::strcmp(stdtype, "bool") == 0)

podType.stdtype = PodType::Type::BOOL;

else if (std::strcmp(stdtype, "char") == 0)

podType.stdtype = PodType::Type::CHAR;

else if (std::strcmp(stdtype, "short") == 0)

podType.stdtype = PodType::Type::SHORT;

else if (std::strcmp(stdtype, "int") == 0)

podType.stdtype = PodType::Type::INT;

else if (std::strcmp(stdtype, "long") == 0)

podType.stdtype = PodType::Type::LONG;

else if (std::strcmp(stdtype, "long long") == 0)

podType.stdtype = PodType::Type::LONGLONG;

}

const char * const size = node->Attribute("size");

if (size)

podType.size = atoi(size);

const char * const sign = node->Attribute("sign");

if (sign)

podType.sign = *sign;

for (const std::string &s : getnames(name))

mPodTypes[s] = podType;

}

else if (nodename == "platformtype") {

const char * const type_name = node->Attribute("name");

if (type_name == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "name");

const char *value = node->Attribute("value");

if (value == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "value");

PlatformType type;

type.mType = value;

std::set<std::string> platform;

for (const tinyxml2::XMLElement *typenode = node->FirstChildElement(); typenode; typenode = typenode->NextSiblingElement()) {

const std::string typenodename = typenode->Name();

if (typenodename == "platform") {

const char * const type_attribute = typenode->Attribute("type");

if (type_attribute == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "type");

platform.insert(type_attribute);

} else if (typenodename == "signed")

type.mSigned = true;

else if (typenodename == "unsigned")

type.mUnsigned = true;

else if (typenodename == "long")

type.mLong = true;

else if (typenodename == "pointer")

type.mPointer= true;

else if (typenodename == "ptr_ptr")

type.mPtrPtr = true;

else if (typenodename == "const_ptr")

type.mConstPtr = true;

else

unknown_elements.insert(typenodename);

}

if (platform.empty()) {

const PlatformType * const type_ptr = platform_type(type_name, emptyString);

if (type_ptr) {

if (*type_ptr == type)

return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);

return Error(ErrorCode::PLATFORM_TYPE_REDEFINED, type_name);

}

mPlatformTypes[type_name] = type;

} else {

for (const std::string &p : platform) {

const PlatformType * const type_ptr = platform_type(type_name, p);

if (type_ptr) {

if (*type_ptr == type)

return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);

return Error(ErrorCode::PLATFORM_TYPE_REDEFINED, type_name);

}

mPlatforms[p].mPlatformTypes[type_name] = type;

}

}

}

else

unknown_elements.insert(nodename);

}

if (!unknown_elements.empty()) {

std::string str;

for (std::set<std::string>::const_iterator i = unknown_elements.begin(); i != unknown_elements.end();) {

str += *i;

if (++i != unknown_elements.end())

str += ", ";

}

return Error(ErrorCode::UNKNOWN_ELEMENT, str);

}

return Error(ErrorCode::OK);

{

if (name.empty())

return Error(ErrorCode::OK);

Function& func = functions[name];

for (const tinyxml2::XMLElement *functionnode = node->FirstChildElement(); functionnode; functionnode = functionnode->NextSiblingElement()) {

const std::string functionnodename = functionnode->Name();

if (functionnodename == "noreturn") {

if (strcmp(functionnode->GetText(), "false") == 0)

mNoReturn[name] = FalseTrueMaybe::False;

else if (strcmp(functionnode->GetText(), "maybe") == 0)

mNoReturn[name] = FalseTrueMaybe::Maybe;

else

mNoReturn[name] = FalseTrueMaybe::True; // Safe

} else if (functionnodename == "pure")

func.ispure = true;

else if (functionnodename == "const") {

func.ispure = true;

func.isconst = true; // a constant function is pure

} else if (functionnodename == "leak-ignore")

func.leakignore = true;

else if (functionnodename == "not-overlapping-data") {

NonOverlappingData nonOverlappingData;

nonOverlappingData.ptr1Arg = functionnode->IntAttribute("ptr1-arg", -1);

nonOverlappingData.ptr2Arg = functionnode->IntAttribute("ptr2-arg", -1);

nonOverlappingData.sizeArg = functionnode->IntAttribute("size-arg", -1);

nonOverlappingData.strlenArg = functionnode->IntAttribute("strlen-arg", -1);

mNonOverlappingData[name] = nonOverlappingData;

} else if (functionnodename == "use-retval") {

func.useretval = Library::UseRetValType::DEFAULT;

if (const char *type = functionnode->Attribute("type"))

if (std::strcmp(type, "error-code") == 0)

func.useretval = Library::UseRetValType::ERROR_CODE;

} else if (functionnodename == "returnValue") {

if (const char *expr = functionnode->GetText())

mReturnValue[name] = expr;

if (const char *type = functionnode->Attribute("type"))

mReturnValueType[name] = type;

if (const char *container = functionnode->Attribute("container"))

mReturnValueContainer[name] = std::atoi(container);

if (const char *unknownReturnValues = functionnode->Attribute("unknownValues")) {

if (std::strcmp(unknownReturnValues, "all") == 0) {

std::vector<MathLib::bigint> values{LLONG_MIN, LLONG_MAX};

mUnknownReturnValues[name] = values;

}

}

} else if (functionnodename == "arg") {

const char* argNrString = functionnode->Attribute("nr");

if (!argNrString)

return Error(ErrorCode::MISSING_ATTRIBUTE, "nr");

const bool bAnyArg = strcmp(argNrString, "any") == 0;

const bool bVariadicArg = strcmp(argNrString, "variadic") == 0;

const int nr = (bAnyArg || bVariadicArg) ? -1 : std::atoi(argNrString);

ArgumentChecks &ac = func.argumentChecks[nr];

ac.optional = functionnode->Attribute("default") != nullptr;

ac.variadic = bVariadicArg;

const char * const argDirection = functionnode->Attribute("direction");

if (argDirection) {

const size_t argDirLen = strlen(argDirection);

if (!strncmp(argDirection, "in", argDirLen)) {

ac.direction = ArgumentChecks::Direction::DIR_IN;

} else if (!strncmp(argDirection, "out", argDirLen)) {

ac.direction = ArgumentChecks::Direction::DIR_OUT;

} else if (!strncmp(argDirection, "inout", argDirLen)) {

ac.direction = ArgumentChecks::Direction::DIR_INOUT;

}

}

for (const tinyxml2::XMLElement *argnode = functionnode->FirstChildElement(); argnode; argnode = argnode->NextSiblingElement()) {

const std::string argnodename = argnode->Name();

int indirect = 0;

const char * const indirectStr = argnode->Attribute("indirect");

if (indirectStr)

indirect = atoi(indirectStr);

if (argnodename == "not-bool")

ac.notbool = true;

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

ac.notnull = true;

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

ac.notuninit = indirect;

else if (argnodename == "formatstr")

ac.formatstr = true;

else if (argnodename == "strz")

ac.strz = true;

else if (argnodename == "valid") {

// Validate the validation expression

const char *p = argnode->GetText();

if (!isCompliantValidationExpression(p))

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, (!p ? "\"\"" : argnode->GetText()));

// Set validation expression

ac.valid = argnode->GetText();

}

else if (argnodename == "minsize") {

const char *typeattr = argnode->Attribute("type");

if (!typeattr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "type");

ArgumentChecks::MinSize::Type type;

if (strcmp(typeattr,"strlen")==0)

type = ArgumentChecks::MinSize::Type::STRLEN;

else if (strcmp(typeattr,"argvalue")==0)

type = ArgumentChecks::MinSize::Type::ARGVALUE;

else if (strcmp(typeattr,"sizeof")==0)

type = ArgumentChecks::MinSize::Type::SIZEOF;

else if (strcmp(typeattr,"mul")==0)

type = ArgumentChecks::MinSize::Type::MUL;

else if (strcmp(typeattr,"value")==0)

type = ArgumentChecks::MinSize::Type::VALUE;

else

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, typeattr);

if (type == ArgumentChecks::MinSize::Type::VALUE) {

const char *valueattr = argnode->Attribute("value");

if (!valueattr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "value");

long long minsizevalue = 0;

try {

minsizevalue = MathLib::toLongNumber(valueattr);

} catch (const InternalError&) {

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, valueattr);

}

if (minsizevalue <= 0)

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, valueattr);

ac.minsizes.emplace_back(type, 0);

ac.minsizes.back().value = minsizevalue;

} else {

const char *argattr = argnode->Attribute("arg");

if (!argattr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "arg");

if (strlen(argattr) != 1 || argattr[0]<'0' || argattr[0]>'9')

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, argattr);

ac.minsizes.reserve(type == ArgumentChecks::MinSize::Type::MUL ? 2 : 1);

ac.minsizes.emplace_back(type, argattr[0] - '0');

if (type == ArgumentChecks::MinSize::Type::MUL) {

const char *arg2attr = argnode->Attribute("arg2");

if (!arg2attr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "arg2");

if (strlen(arg2attr) != 1 || arg2attr[0]<'0' || arg2attr[0]>'9')

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, arg2attr);

ac.minsizes.back().arg2 = arg2attr[0] - '0';

}

}

}

else if (argnodename == "iterator") {

ac.iteratorInfo.it = true;

const char* str = argnode->Attribute("type");

ac.iteratorInfo.first = (str && std::strcmp(str, "first") == 0);

ac.iteratorInfo.last = (str && std::strcmp(str, "last") == 0);

ac.iteratorInfo.container = argnode->IntAttribute("container", 0);

}

else

unknown_elements.insert(argnodename);

}

if (ac.notuninit == 0)

ac.notuninit = ac.notnull ? 1 : 0;

} else if (functionnodename == "ignorefunction") {

func.ignore = true;

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

func.formatstr = true;

const tinyxml2::XMLAttribute* scan = functionnode->FindAttribute("scan");

const tinyxml2::XMLAttribute* secure = functionnode->FindAttribute("secure");

func.formatstr_scan = scan && scan->BoolValue();

func.formatstr_secure = secure && secure->BoolValue();

} else if (functionnodename == "warn") {

WarnInfo wi;

const char* const severity = functionnode->Attribute("severity");

if (severity == nullptr)

return Error(ErrorCode::MISSING_ATTRIBUTE, "severity");

wi.severity = Severity::fromString(severity);

const char* const cstd = functionnode->Attribute("cstd");

if (cstd) {

if (!wi.standards.setC(cstd))

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, cstd);

} else

wi.standards.c = Standards::C89;

const char* const cppstd = functionnode->Attribute("cppstd");

if (cppstd) {

if (!wi.standards.setCPP(cppstd))

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, cppstd);

} else

wi.standards.cpp = Standards::CPP03;

const char* const reason = functionnode->Attribute("reason");

const char* const alternatives = functionnode->Attribute("alternatives");

if (reason && alternatives) {

// Construct message

wi.message = std::string(reason) + " function '" + name + "' called. It is recommended to use ";

std::vector<std::string> alt = getnames(alternatives);

for (std::size_t i = 0; i < alt.size(); ++i) {

wi.message += "'" + alt[i] + "'";

if (i == alt.size() - 1)

wi.message += " instead.";

else if (i == alt.size() - 2)

wi.message += " or ";

else

wi.message += ", ";

}

} else {

const char * const message = functionnode->GetText();

if (!message) {

return Error(ErrorCode::MISSING_ATTRIBUTE, "\"reason\" and \"alternatives\" or some text.");

} else

wi.message = message;

}

functionwarn[name] = wi;

} else if (functionnodename == "container") {

const char* const action_ptr = functionnode->Attribute("action");

Container::Action action = Container::Action::NO_ACTION;

if (action_ptr) {

std::string actionName = action_ptr;

action = Container::actionFrom(actionName);

if (action == Container::Action::NO_ACTION)

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, actionName);

}

func.containerAction = action;

const char* const yield_ptr = functionnode->Attribute("yields");

Container::Yield yield = Container::Yield::NO_YIELD;

if (yield_ptr) {

std::string yieldName = yield_ptr;

yield = Container::yieldFrom(yieldName);

if (yield == Container::Yield::NO_YIELD)

return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, yieldName);

}

func.containerYield = yield;

} else

unknown_elements.insert(functionnodename);

}

return Error(ErrorCode::OK);

{

const ArgumentChecks *ac = getarg(ftok, argnr);

if (!ac || ac->valid.empty())

return true;

else if (ac->valid.find('.') != std::string::npos)

return isFloatArgValid(ftok, argnr, argvalue);

TokenList tokenList(nullptr);

gettokenlistfromvalid(ac->valid, tokenList);

for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {

if (tok->isNumber() && argvalue == MathLib::toLongNumber(tok->str()))

return true;

if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toLongNumber(tok->str()) && argvalue <= MathLib::toLongNumber(tok->strAt(2)))

return true;

if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toLongNumber(tok->str()))

return true;

if ((!tok->previous() || tok->previous()->str() == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toLongNumber(tok->strAt(1)))

return true;

}

return false;

{

const ArgumentChecks *ac = getarg(ftok, argnr);

if (!ac || ac->valid.empty())

return true;

TokenList tokenList(nullptr);

gettokenlistfromvalid(ac->valid, tokenList);

for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {

if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toDoubleNumber(tok->str()) && argvalue <= MathLib::toDoubleNumber(tok->strAt(2)))

return true;

if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toDoubleNumber(tok->str()))

return true;

if ((!tok->previous() || tok->previous()->str() == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toDoubleNumber(tok->strAt(1)))

return true;

if (Token::Match(tok, "%num%") && MathLib::isFloat(tok->str()) && MathLib::isEqual(tok->str(), MathLib::toString(argvalue)))

return true;

if (Token::Match(tok, "! %num%") && MathLib::isFloat(tok->next()->str()))

return MathLib::isNotEqual(tok->next()->str(), MathLib::toString(argvalue));

}

return false;

{

if (!ftok) {

*error = true;

return "";

}

if (ftok->isName()) {

for (const Scope *scope = ftok->scope(); scope; scope = scope->nestedIn) {

if (!scope->isClassOrStruct())

continue;

const std::vector<Type::BaseInfo> &derivedFrom = scope->definedType->derivedFrom;

for (const Type::BaseInfo & baseInfo : derivedFrom) {

const std::string name(baseInfo.name + "::" + ftok->str());

if (functions.find(name) != functions.end() && matchArguments(ftok, name))

return name;

}

}

return ftok->str();

}

if (ftok->str() == "::") {

if (!ftok->astOperand2())

return getFunctionName(ftok->astOperand1(), error);

return getFunctionName(ftok->astOperand1(),error) + "::" + getFunctionName(ftok->astOperand2(),error);

}

if (ftok->str() == "." && ftok->astOperand1()) {

const std::string type = astCanonicalType(ftok->astOperand1());

if (type.empty()) {

*error = true;

return "";

}

return type + "::" + getFunctionName(ftok->astOperand2(),error);

}

*error = true;

return "";

{

if (!Token::Match(ftok, "%name% (") && (ftok->strAt(-1) != "&" || ftok->previous()->astOperand2()))

return "";

// Lookup function name using AST..

if (ftok->astParent()) {

bool error = false;

const Token * tok = ftok->astParent()->isUnaryOp("&") ? ftok->astParent()->astOperand1() : ftok->next()->astOperand1();

const std::string ret = getFunctionName(tok, &error);

return error ? std::string() : ret;

}

// Lookup function name without using AST..

if (Token::simpleMatch(ftok->previous(), "."))

return "";

if (!Token::Match(ftok->tokAt(-2), "%name% ::"))

return ftok->str();

std::string ret(ftok->str());

ftok = ftok->tokAt(-2);

while (Token::Match(ftok, "%name% ::")) {

ret = ftok->str() + "::" + ret;

ftok = ftok->tokAt(-2);