/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2024 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

// This file is auto-generated by tools/get_checkers.py:

// python3 tools/get_checkers.py > lib/checkers.cpp

#include "checkers.h"

namespace checkers {

const std::map<std::string, std::string> allCheckers{

{"CheckBool::checkIncrementBoolean","style"},

{"CheckBool::checkBitwiseOnBoolean","style,inconclusive"},

{"CheckBool::checkComparisonOfBoolWithInt","warning,c++"},

{"CheckBool::checkComparisonOfFuncReturningBool","style,c++"},

{"CheckBool::checkComparisonOfBoolWithBool","style,c++"},

{"CheckBool::checkAssignBoolToPointer",""},

{"CheckBool::checkComparisonOfBoolExpressionWithInt","warning"},

{"CheckBool::pointerArithBool",""},

{"CheckBool::checkAssignBoolToFloat","style,c++"},

{"CheckBool::returnValueOfFunctionReturningBool","style"},

{"CheckPostfixOperator::postfixOperator","performance"},

{"CheckSizeof::checkSizeofForNumericParameter","warning"},

{"CheckSizeof::checkSizeofForArrayParameter","warning"},

{"CheckSizeof::checkSizeofForPointerSize","warning"},

{"CheckSizeof::sizeofsizeof","warning"},

{"CheckSizeof::sizeofCalculation","warning"},

{"CheckSizeof::sizeofFunction","warning"},

{"CheckSizeof::suspiciousSizeofCalculation","warning,inconclusive"},

{"CheckSizeof::sizeofVoid","portability"},

{"Check64BitPortability::pointerassignment","portability"},

{"CheckStl::outOfBounds",""},

{"CheckStl::outOfBoundsIndexExpression",""},

{"CheckStl::iterators",""},

{"CheckStl::misMatchingContainers",""},

{"CheckStl::misMatchingContainerIterator",""},

{"CheckStl::invalidContainer",""},

{"CheckStl::stlOutOfBounds",""},

{"CheckStl::negativeIndex",""},

{"CheckStl::erase",""},

{"CheckStl::stlBoundaries",""},

{"CheckStl::if_find","warning,performance"},

{"CheckStl::checkFindInsert","performance"},

{"CheckStl::size","performance,c++03"},

{"CheckStl::redundantCondition","style"},

{"CheckStl::missingComparison","warning"},

{"CheckStl::string_c_str",""},

{"CheckStl::uselessCalls","performance,warning"},

{"CheckStl::checkDereferenceInvalidIterator","warning"},

{"CheckStl::checkDereferenceInvalidIterator2",""},

{"CheckStl::useStlAlgorithm","style"},

{"CheckStl::knownEmptyContainer","style"},

{"CheckStl::eraseIteratorOutOfBounds",""},

{"CheckStl::checkMutexes","warning"},

{"CheckBoost::checkBoostForeachModification",""},

{"CheckNullPointer::nullPointer",""},

{"CheckNullPointer::nullConstantDereference",""},

{"CheckNullPointer::arithmetic",""},

{"CheckNullPointer::analyseWholeProgram","unusedfunctions"},

{"CheckBufferOverrun::arrayIndex",""},

{"CheckBufferOverrun::pointerArithmetic","portability"},

{"CheckBufferOverrun::bufferOverflow",""},

{"CheckBufferOverrun::arrayIndexThenCheck",""},

{"CheckBufferOverrun::stringNotZeroTerminated","warning,inconclusive"},

{"CheckBufferOverrun::argumentSize","warning"},

{"CheckBufferOverrun::analyseWholeProgram",""},

{"CheckBufferOverrun::objectIndex",""},

{"CheckBufferOverrun::negativeArraySize",""},

{"CheckUninitVar::check",""},

{"CheckUninitVar::valueFlowUninit",""},

{"CheckOther::checkCastIntToCharAndBack","warning"},

{"CheckOther::clarifyCalculation","style"},

{"CheckOther::clarifyStatement","warning"},

{"CheckOther::checkSuspiciousSemicolon","warning,inconclusive"},

{"CheckOther::warningOldStylePointerCast","style,c++"},

{"CheckOther::suspiciousFloatingPointCast","style"},

{"CheckOther::invalidPointerCast","portability"},

{"CheckOther::checkRedundantAssignment","style"},

{"CheckOther::redundantBitwiseOperationInSwitch","warning"},

{"CheckOther::checkSuspiciousCaseInSwitch","warning,inconclusive"},

{"CheckOther::checkUnreachableCode","style"},

{"CheckOther::checkVariableScope","style,notclang"},

{"CheckOther::checkPassByReference","performance,c++"},

{"CheckOther::checkConstVariable","style,c++"},

{"CheckOther::checkConstPointer","style"},

{"CheckOther::checkCharVariable","warning,portability"},

{"CheckOther::checkIncompleteStatement","warning"},

{"CheckOther::checkZeroDivision",""},

{"CheckOther::checkNanInArithmeticExpression","style"},

{"CheckOther::checkMisusedScopedObject","style,c++"},

{"CheckOther::checkDuplicateBranch","style,inconclusive"},

{"CheckOther::checkInvalidFree",""},

{"CheckOther::checkDuplicateExpression","style,warning"},

{"CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalse","warning"},

{"CheckOther::checkSignOfUnsignedVariable","style"},

{"CheckOther::checkRedundantCopy","c++,performance,inconclusive"},

{"CheckOther::checkNegativeBitwiseShift",""},

{"CheckOther::checkIncompleteArrayFill","warning,portability,inconclusive"},

{"CheckOther::checkVarFuncNullUB","portability"},

{"CheckOther::checkRedundantPointerOp","style"},

{"CheckOther::checkInterlockedDecrement","windows-platform"},

{"CheckOther::checkUnusedLabel","style,warning"},

{"CheckOther::checkEvaluationOrder",""},

{"CheckOther::checkAccessOfMovedVariable","c++11,warning"},

{"CheckOther::checkFuncArgNamesDifferent","style,warning,inconclusive"},

{"CheckOther::checkShadowVariables","style"},

{"CheckOther::checkKnownArgument","style"},

{"CheckOther::checkKnownPointerToBool","style"},

{"CheckOther::checkComparePointers",""},

{"CheckOther::checkModuloOfOne","style"},

{"CheckOther::checkOverlappingWrite",""},

{"CheckClass::checkConstructors","style,warning"},

{"CheckClass::checkExplicitConstructors","style"},

{"CheckClass::checkCopyConstructors","warning"},

{"CheckClass::initializationListUsage","performance"},

{"CheckClass::privateFunctions","style"},

{"CheckClass::checkMemset",""},

{"CheckClass::operatorEqRetRefThis","style"},

{"CheckClass::operatorEqToSelf","warning"},

{"CheckClass::virtualDestructor",""},

{"CheckClass::thisSubtraction","warning"},

{"CheckClass::checkConst","style,inconclusive"},

{"CheckClass::initializerListOrder","style,inconclusive"},

{"CheckClass::checkSelfInitialization",""},

{"CheckClass::checkVirtualFunctionCallInConstructor","warning"},

{"CheckClass::checkDuplInheritedMembers","warning"},

{"CheckClass::checkMissingOverride","style,c++03"},

{"CheckClass::checkUselessOverride","style"},

{"CheckClass::checkReturnByReference","performance"},

{"CheckClass::checkThisUseAfterFree","warning"},

{"CheckClass::checkUnsafeClassRefMember","warning,safeChecks"},

{"CheckClass::analyseWholeProgram",""},

{"CheckUnusedVar::checkFunctionVariableUsage","style"},

{"CheckUnusedVar::checkStructMemberUsage","style"},

{"CheckIO::checkCoutCerrMisusage","c"},

{"CheckIO::checkFileUsage",""},

{"CheckIO::invalidScanf",""},

{"CheckIO::checkWrongPrintfScanfArguments",""},

{"CheckCondition::assignIf","style"},

{"CheckCondition::checkBadBitmaskCheck","style"},

{"CheckCondition::comparison","style"},

{"CheckCondition::duplicateCondition","style"},

{"CheckCondition::multiCondition","style"},

{"CheckCondition::multiCondition2","warning"},

{"CheckCondition::checkIncorrectLogicOperator","style,warning"},

{"CheckCondition::checkModuloAlwaysTrueFalse","warning"},

{"CheckCondition::clarifyCondition","style"},

{"CheckCondition::alwaysTrueFalse","style"},

{"CheckCondition::checkInvalidTestForOverflow","warning"},

{"CheckCondition::checkPointerAdditionResultNotNull","warning"},

{"CheckCondition::checkDuplicateConditionalAssign","style"},

{"CheckCondition::checkAssignmentInCondition","style"},

{"CheckCondition::checkCompareValueOutOfTypeRange","style,platform"},

{"CheckFunctions::checkProhibitedFunctions",""},

{"CheckFunctions::invalidFunctionUsage",""},

{"CheckFunctions::checkIgnoredReturnValue","style,warning"},

{"CheckFunctions::checkMissingReturn",""},

{"CheckFunctions::checkMathFunctions","style,warning,c99,c++11"},

{"CheckFunctions::memsetZeroBytes","warning"},

{"CheckFunctions::memsetInvalid2ndParam","warning,portability"},

{"CheckFunctions::returnLocalStdMove","performance,c++11"},

{"CheckFunctions::useStandardLibrary","style"},

{"CheckVaarg::va_start_argument",""},

{"CheckVaarg::va_list_usage","notclang"},

{"CheckUnusedFunctions::check","unusedFunction"},

{"CheckType::checkTooBigBitwiseShift","platform"},

{"CheckType::checkIntegerOverflow","platform"},

{"CheckType::checkSignConversion","warning"},

{"CheckType::checkLongCast","style"},

{"CheckType::checkFloatToIntegerOverflow",""},

{"CheckString::stringLiteralWrite",""},

{"CheckString::checkAlwaysTrueOrFalseStringCompare","warning"},

{"CheckString::checkSuspiciousStringCompare","warning"},

{"CheckString::strPlusChar",""},

{"CheckString::checkIncorrectStringCompare","warning"},

{"CheckString::overlappingStrcmp","warning"},

{"CheckString::sprintfOverlappingData",""},

{"CheckAssert::assertWithSideEffects","warning"},

{"CheckExceptionSafety::destructors","warning"},

{"CheckExceptionSafety::deallocThrow","warning"},

{"CheckExceptionSafety::checkRethrowCopy","style"},

{"CheckExceptionSafety::checkCatchExceptionByValue","style"},

{"CheckExceptionSafety::nothrowThrows",""},

{"CheckExceptionSafety::unhandledExceptionSpecification","style,inconclusive"},

{"CheckExceptionSafety::rethrowNoCurrentException",""},

{"CheckAutoVariables::assignFunctionArg","style,warning"},

{"CheckAutoVariables::autoVariables",""},

{"CheckAutoVariables::checkVarLifetime",""},

{"CheckLeakAutoVar::check","notclang"},

{"CheckMemoryLeakInFunction::checkReallocUsage",""},

{"CheckMemoryLeakInClass::check",""},

{"CheckMemoryLeakStructMember::check",""},

{"CheckMemoryLeakNoVar::check",""},

{"CheckMemoryLeakNoVar::checkForUnsafeArgAlloc",""},

};

const std::map<std::string, std::string> premiumCheckers{

{"Autosar: A0-1-3",""},

{"Autosar: A0-1-4",""},

{"Autosar: A0-1-5",""},

{"Autosar: A0-1-6",""},

{"Autosar: A0-4-2",""},

{"Autosar: A0-4-4",""},

{"Autosar: A10-1-1",""},

{"Autosar: A11-0-2",""},

{"Autosar: A11-3-1",""},

{"Autosar: A13-2-1",""},

{"Autosar: A13-2-3",""},

{"Autosar: A13-5-2",""},

{"Autosar: A13-5-5",""},

{"Autosar: A15-1-2",""},

{"Autosar: A15-3-5",""},

{"Autosar: A16-6-1",""},

{"Autosar: A16-7-1",""},

{"Autosar: A18-0-3",""},

{"Autosar: A18-1-1",""},

{"Autosar: A18-1-2",""},

{"Autosar: A18-1-3",""},

{"Autosar: A18-5-1",""},

{"Autosar: A18-9-1",""},

{"Autosar: A2-11-1",""},

{"Autosar: A2-13-1",""},

{"Autosar: A2-13-3",""},

{"Autosar: A2-13-5",""},

{"Autosar: A2-5-2",""},

{"Autosar: A2-7-1",""},

{"Autosar: A20-8-2","warning"},

{"Autosar: A20-8-3","warning"},

{"Autosar: A20-8-4",""},

{"Autosar: A20-8-5",""},

{"Autosar: A20-8-6",""},

{"Autosar: A21-8-1","warning"},

{"Autosar: A23-0-1",""},

{"Autosar: A25-1-1","warning"},

{"Autosar: A25-4-1","warning"},

{"Autosar: A26-5-1",""},

{"Autosar: A26-5-2",""},

{"Autosar: A27-0-1","warning"},

{"Autosar: A27-0-2",""},

{"Autosar: A27-0-4",""},

{"Autosar: A3-1-3",""},

{"Autosar: A3-1-4",""},

{"Autosar: A3-3-1",""},

{"Autosar: A3-9-1",""},

{"Autosar: A4-10-1",""},

{"Autosar: A4-7-1",""},

{"Autosar: A5-0-2",""},

{"Autosar: A5-0-3",""},

{"Autosar: A5-0-4",""},

{"Autosar: A5-1-1",""},

{"Autosar: A5-1-2",""},

{"Autosar: A5-1-3",""},

{"Autosar: A5-1-6",""},

{"Autosar: A5-1-7",""},

{"Autosar: A5-16-1",""},

{"Autosar: A5-2-1",""},

{"Autosar: A5-2-3",""},

{"Autosar: A5-2-4",""},

{"Autosar: A5-3-3",""},

{"Autosar: A6-5-3",""},

{"Autosar: A7-1-4",""},

{"Autosar: A7-1-6",""},

{"Autosar: A7-1-7",""},

{"Autosar: A7-2-1",""},

{"Autosar: A7-2-2",""},

{"Autosar: A7-6-1",""},

{"Autosar: A8-4-1",""},

{"Autosar: A8-5-3",""},

{"Autosar: A9-3-1",""},

{"Cert C++: CON50-CPP",""},

{"Cert C++: CON51-CPP",""},

{"Cert C++: CON52-CPP",""},

{"Cert C++: CON53-CPP",""},

{"Cert C++: CON54-CPP",""},

{"Cert C++: CON55-CPP",""},

{"Cert C++: CON56-CPP",""},

{"Cert C++: CTR50-CPP",""},

{"Cert C++: CTR52-CPP",""},

{"Cert C++: CTR53-CPP",""},

{"Cert C++: CTR56-CPP",""},

{"Cert C++: CTR57-CPP","warning"},

{"Cert C++: CTR58-CPP","warning"},

{"Cert C++: DCL50-CPP",""},

{"Cert C++: DCL51-CPP",""},

{"Cert C++: DCL52-CPP",""},

{"Cert C++: DCL53-CPP",""},

{"Cert C++: DCL54-CPP",""},

{"Cert C++: DCL56-CPP",""},

{"Cert C++: DCL58-CPP",""},

{"Cert C++: DCL59-CPP",""},

{"Cert C++: ERR50-CPP",""},

{"Cert C++: ERR51-CPP",""},

{"Cert C++: ERR52-CPP",""},

{"Cert C++: ERR53-CPP",""},

{"Cert C++: ERR54-CPP",""},

{"Cert C++: ERR55-CPP",""},

{"Cert C++: ERR56-CPP",""},

{"Cert C++: ERR58-CPP",""},

{"Cert C++: ERR59-CPP","warning"},

{"Cert C++: ERR60-CPP","warning"},

{"Cert C++: ERR61-CPP",""},

{"Cert C++: ERR62-CPP",""},

{"Cert C++: EXP50-CPP",""},

{"Cert C++: EXP51-CPP",""},

{"Cert C++: EXP55-CPP",""},

{"Cert C++: EXP56-CPP",""},

{"Cert C++: EXP57-CPP",""},

{"Cert C++: EXP58-CPP",""},

{"Cert C++: EXP59-CPP",""},

{"Cert C++: EXP60-CPP",""},

{"Cert C++: FIO51-CPP",""},

{"Cert C++: INT50-CPP",""},

{"Cert C++: MEM52-CPP",""},

{"Cert C++: MEM53-CPP",""},

{"Cert C++: MEM54-CPP",""},

{"Cert C++: MEM55-CPP",""},

{"Cert C++: MEM57-CPP",""},

{"Cert C++: MSC50-CPP",""},

{"Cert C++: MSC51-CPP",""},

{"Cert C++: MSC53-CPP",""},

{"Cert C++: MSC54-CPP",""},

{"Cert C++: OOP51-CPP",""},

{"Cert C++: OOP55-CPP",""},

{"Cert C++: OOP56-CPP",""},

{"Cert C++: OOP57-CPP",""},

{"Cert C++: OOP58-CPP",""},

{"Cert C++: STR50-CPP",""},

{"Cert C++: STR53-CPP",""},

{"Cert C: ARR30-C",""},

{"Cert C: ARR32-C",""},

{"Cert C: ARR37-C",""},

{"Cert C: ARR38-C",""},

{"Cert C: ARR39-C",""},

{"Cert C: CON30-C",""},

{"Cert C: CON31-C",""},

{"Cert C: CON32-C",""},

{"Cert C: CON33-C",""},

{"Cert C: CON34-C",""},

{"Cert C: CON35-C",""},

{"Cert C: CON36-C",""},

{"Cert C: CON37-C",""},

{"Cert C: CON38-C",""},

{"Cert C: CON39-C",""},

{"Cert C: CON40-C",""},

{"Cert C: CON41-C",""},

{"Cert C: DCL31-C",""},

{"Cert C: DCL36-C",""},

{"Cert C: DCL37-C",""},

{"Cert C: DCL38-C",""},

{"Cert C: DCL39-C",""},

{"Cert C: DCL40-C",""},

{"Cert C: DCL41-C",""},

{"Cert C: ENV30-C",""},

{"Cert C: ENV31-C",""},

{"Cert C: ENV32-C",""},

{"Cert C: ENV33-C",""},

{"Cert C: ENV34-C",""},

{"Cert C: ERR30-C",""},

{"Cert C: ERR32-C",""},

{"Cert C: ERR33-C",""},

{"Cert C: EXP03-C",""},

{"Cert C: EXP05-C",""},

{"Cert C: EXP09-C",""},

{"Cert C: EXP13-C",""},

{"Cert C: EXP15-C",""},

{"Cert C: EXP19-C",""},

{"Cert C: EXP32-C",""},

{"Cert C: EXP35-C",""},

{"Cert C: EXP36-C",""},

{"Cert C: EXP37-C",""},

{"Cert C: EXP39-C",""},

{"Cert C: EXP40-C",""},

{"Cert C: EXP42-C",""},

{"Cert C: EXP43-C",""},

{"Cert C: EXP45-C",""},

{"Cert C: FIO30-C",""},

{"Cert C: FIO32-C",""},

{"Cert C: FIO34-C",""},

{"Cert C: FIO37-C",""},

{"Cert C: FIO38-C",""},

{"Cert C: FIO40-C",""},

{"Cert C: FIO41-C",""},

{"Cert C: FIO44-C",""},

{"Cert C: FIO45-C",""},

{"Cert C: FLP30-C",""},

{"Cert C: FLP36-C","portability"},

{"Cert C: FLP37-C",""},

{"Cert C: INT30-C",""},

{"Cert C: INT31-C",""},

{"Cert C: INT32-C",""},

{"Cert C: INT33-C",""},

{"Cert C: INT34-C",""},

{"Cert C: INT35-C",""},

{"Cert C: INT36-C",""},

{"Cert C: MEM33-C",""},

{"Cert C: MEM35-C",""},

{"Cert C: MEM36-C",""},

{"Cert C: MSC30-C",""},

{"Cert C: MSC32-C",""},

{"Cert C: MSC33-C",""},

{"Cert C: MSC38-C",""},

{"Cert C: MSC39-C",""},

{"Cert C: MSC40-C",""},

{"Cert C: PRE31-C",""},

{"Cert C: SIG30-C",""},

{"Cert C: SIG31-C",""},

{"Cert C: SIG34-C",""},

{"Cert C: SIG35-C",""},

{"Cert C: STR31-C",""},

{"Cert C: STR32-C",""},

{"Cert C: STR34-C",""},

{"Cert C: STR38-C",""},

{"Misra C++ 2008: 3-2-3",""},

{"Misra C++ 2008: 3-2-4",""},

{"Misra C++ 2008: 7-5-4",""},

{"Misra C++ 2008: M0-1-11",""},

{"Misra C++ 2008: M0-1-12",""},

{"Misra C++ 2008: M0-1-4",""},

{"Misra C++ 2008: M0-1-5",""},

{"Misra C++ 2008: M0-1-7",""},

{"Misra C++ 2008: M0-1-8",""},

{"Misra C++ 2008: M0-3-2",""},

{"Misra C++ 2008: M1-0-1","portability"},

{"Misra C++ 2008: M10-1-1",""},

{"Misra C++ 2008: M10-1-2",""},

{"Misra C++ 2008: M10-1-3",""},

{"Misra C++ 2008: M10-2-1",""},

{"Misra C++ 2008: M10-3-1",""},

{"Misra C++ 2008: M10-3-2",""},

{"Misra C++ 2008: M10-3-3",""},

{"Misra C++ 2008: M11-0-1",""},

{"Misra C++ 2008: M12-1-2",""},

{"Misra C++ 2008: M12-8-1",""},

{"Misra C++ 2008: M12-8-2",""},

{"Misra C++ 2008: M14-5-1","warning"},

{"Misra C++ 2008: M14-5-2","warning"},

{"Misra C++ 2008: M14-5-3","warning"},

{"Misra C++ 2008: M14-6-1","warning"},

{"Misra C++ 2008: M14-6-2","warning"},

{"Misra C++ 2008: M14-7-1",""},

{"Misra C++ 2008: M14-7-2",""},

{"Misra C++ 2008: M14-7-3",""},

{"Misra C++ 2008: M14-8-1",""},

{"Misra C++ 2008: M14-8-2",""},

{"Misra C++ 2008: M15-0-3",""},

{"Misra C++ 2008: M15-1-1",""},

{"Misra C++ 2008: M15-1-2",""},

{"Misra C++ 2008: M15-1-3",""},

{"Misra C++ 2008: M15-3-2","warning"},

{"Misra C++ 2008: M15-3-3",""},

{"Misra C++ 2008: M15-3-4",""},

{"Misra C++ 2008: M15-3-6",""},

{"Misra C++ 2008: M15-3-7",""},

{"Misra C++ 2008: M15-4-1",""},

{"Misra C++ 2008: M15-5-2",""},

{"Misra C++ 2008: M16-0-1",""},

{"Misra C++ 2008: M16-0-2",""},

{"Misra C++ 2008: M16-0-3",""},

{"Misra C++ 2008: M16-0-4",""},

{"Misra C++ 2008: M16-0-6",""},

{"Misra C++ 2008: M16-0-7",""},

{"Misra C++ 2008: M16-0-8",""},

{"Misra C++ 2008: M16-1-1",""},

{"Misra C++ 2008: M16-1-2",""},

{"Misra C++ 2008: M16-2-1",""},

{"Misra C++ 2008: M16-2-2",""},

{"Misra C++ 2008: M16-2-3",""},

{"Misra C++ 2008: M16-2-4",""},

{"Misra C++ 2008: M16-2-5",""},

{"Misra C++ 2008: M16-2-6",""},

{"Misra C++ 2008: M16-3-1",""},

{"Misra C++ 2008: M16-3-2",""},

{"Misra C++ 2008: M17-0-1",""},

{"Misra C++ 2008: M17-0-2",""},

{"Misra C++ 2008: M17-0-3",""},

{"Misra C++ 2008: M17-0-5",""},

{"Misra C++ 2008: M18-0-1",""},

{"Misra C++ 2008: M18-0-2",""},

{"Misra C++ 2008: M18-0-3",""},

{"Misra C++ 2008: M18-0-4",""},

{"Misra C++ 2008: M18-0-5",""},

{"Misra C++ 2008: M18-2-1",""},

{"Misra C++ 2008: M18-4-1",""},

{"Misra C++ 2008: M18-7-1",""},

{"Misra C++ 2008: M19-3-1",""},

{"Misra C++ 2008: M2-10-1",""},

{"Misra C++ 2008: M2-10-3",""},

{"Misra C++ 2008: M2-10-4",""},

{"Misra C++ 2008: M2-10-5",""},

{"Misra C++ 2008: M2-10-6",""},

{"Misra C++ 2008: M2-13-2",""},

{"Misra C++ 2008: M2-13-3",""},

{"Misra C++ 2008: M2-13-4",""},

{"Misra C++ 2008: M2-13-5",""},

{"Misra C++ 2008: M2-3-1",""},

{"Misra C++ 2008: M2-7-1",""},

{"Misra C++ 2008: M2-7-2",""},

{"Misra C++ 2008: M2-7-3",""},

{"Misra C++ 2008: M27-0-1",""},

{"Misra C++ 2008: M3-1-1",""},

{"Misra C++ 2008: M3-1-2",""},

{"Misra C++ 2008: M3-1-3",""},

{"Misra C++ 2008: M3-2-1",""},

{"Misra C++ 2008: M3-3-1",""},

{"Misra C++ 2008: M3-3-2",""},

{"Misra C++ 2008: M3-9-1",""},

{"Misra C++ 2008: M3-9-2",""},

{"Misra C++ 2008: M3-9-3",""},

{"Misra C++ 2008: M4-10-1",""},

{"Misra C++ 2008: M4-10-2",""},

{"Misra C++ 2008: M4-5-1",""},

{"Misra C++ 2008: M4-5-2",""},

{"Misra C++ 2008: M4-5-3",""},

{"Misra C++ 2008: M5-0-10",""},

{"Misra C++ 2008: M5-0-11",""},

{"Misra C++ 2008: M5-0-12",""},

{"Misra C++ 2008: M5-0-14",""},

{"Misra C++ 2008: M5-0-15",""},

{"Misra C++ 2008: M5-0-2",""},

{"Misra C++ 2008: M5-0-20",""},

{"Misra C++ 2008: M5-0-21",""},

{"Misra C++ 2008: M5-0-3",""},

{"Misra C++ 2008: M5-0-4",""},

{"Misra C++ 2008: M5-0-5",""},

{"Misra C++ 2008: M5-0-6",""},

{"Misra C++ 2008: M5-0-7",""},

{"Misra C++ 2008: M5-0-8",""},

{"Misra C++ 2008: M5-0-9",""},

{"Misra C++ 2008: M5-14-1",""},

{"Misra C++ 2008: M5-17-1",""},

{"Misra C++ 2008: M5-18-1",""},

{"Misra C++ 2008: M5-19-1",""},

{"Misra C++ 2008: M5-2-1",""},

{"Misra C++ 2008: M5-2-10",""},

{"Misra C++ 2008: M5-2-11",""},

{"Misra C++ 2008: M5-2-12",""},

{"Misra C++ 2008: M5-2-2",""},

{"Misra C++ 2008: M5-2-3",""},

{"Misra C++ 2008: M5-2-5",""},

{"Misra C++ 2008: M5-2-6",""},

{"Misra C++ 2008: M5-2-7",""},

{"Misra C++ 2008: M5-2-8",""},

{"Misra C++ 2008: M5-2-9",""},

{"Misra C++ 2008: M5-3-1",""},

{"Misra C++ 2008: M5-3-2",""},

{"Misra C++ 2008: M5-3-3",""},

{"Misra C++ 2008: M6-2-1",""},

{"Misra C++ 2008: M6-2-2",""},

{"Misra C++ 2008: M6-2-3",""},

{"Misra C++ 2008: M6-3-1",""},

{"Misra C++ 2008: M6-4-1",""},

{"Misra C++ 2008: M6-4-2",""},

{"Misra C++ 2008: M6-4-3",""},

{"Misra C++ 2008: M6-4-4",""},

{"Misra C++ 2008: M6-4-5",""},

{"Misra C++ 2008: M6-4-6",""},

{"Misra C++ 2008: M6-4-7",""},

{"Misra C++ 2008: M6-4-8",""},

{"Misra C++ 2008: M6-5-1",""},

{"Misra C++ 2008: M6-5-2",""},

{"Misra C++ 2008: M6-5-3",""},

{"Misra C++ 2008: M6-5-4",""},

{"Misra C++ 2008: M6-5-5",""},

{"Misra C++ 2008: M6-5-6",""},

{"Misra C++ 2008: M6-6-1",""},

{"Misra C++ 2008: M6-6-2",""},

{"Misra C++ 2008: M6-6-3",""},

{"Misra C++ 2008: M6-6-4",""},

{"Misra C++ 2008: M6-6-5",""},

{"Misra C++ 2008: M7-2-1",""},

{"Misra C++ 2008: M7-3-1",""},

{"Misra C++ 2008: M7-3-2",""},

{"Misra C++ 2008: M7-3-3",""},

{"Misra C++ 2008: M7-3-4",""},

{"Misra C++ 2008: M7-3-5",""},

{"Misra C++ 2008: M7-3-6",""},

{"Misra C++ 2008: M7-4-2",""},

{"Misra C++ 2008: M7-4-3",""},

{"Misra C++ 2008: M7-5-3",""},

{"Misra C++ 2008: M8-0-1",""},

{"Misra C++ 2008: M8-3-1",""},

{"Misra C++ 2008: M8-4-4",""},

{"Misra C++ 2008: M8-5-2",""},

{"Misra C++ 2008: M8-5-3",""},

{"Misra C++ 2008: M9-3-1",""},

{"Misra C++ 2008: M9-5-1",""},

{"Misra C++ 2008: M9-6-2",""},

{"Misra C++ 2008: M9-6-3",""},

{"Misra C++ 2008: M9-6-4",""},

{"Misra C++ 2023: 0.1.2",""},

{"Misra C++ 2023: 0.2.1",""},

{"Misra C++ 2023: 0.2.2",""},

{"Misra C++ 2023: 0.2.3",""},

{"Misra C++ 2023: 0.2.4",""},

{"Misra C++ 2023: 10.0.1",""},

{"Misra C++ 2023: 10.1.2",""},

{"Misra C++ 2023: 10.2.1",""},

{"Misra C++ 2023: 10.2.2",""},

{"Misra C++ 2023: 10.2.3",""},

{"Misra C++ 2023: 10.3.1",""},

{"Misra C++ 2023: 10.4.1",""},

{"Misra C++ 2023: 11.3.1",""},

{"Misra C++ 2023: 11.3.2",""},

{"Misra C++ 2023: 11.6.1",""},

{"Misra C++ 2023: 11.6.3",""},

{"Misra C++ 2023: 12.2.1",""},

{"Misra C++ 2023: 12.2.2",""},

{"Misra C++ 2023: 12.2.3",""},

{"Misra C++ 2023: 12.3.1",""},

{"Misra C++ 2023: 13.1.1",""},

{"Misra C++ 2023: 13.1.2",""},

{"Misra C++ 2023: 13.3.1",""},

{"Misra C++ 2023: 13.3.2",""},

{"Misra C++ 2023: 13.3.3",""},

{"Misra C++ 2023: 13.3.4",""},

{"Misra C++ 2023: 14.1.1",""},

{"Misra C++ 2023: 15.0.1",""},

{"Misra C++ 2023: 15.0.2",""},

{"Misra C++ 2023: 15.1.2",""},

{"Misra C++ 2023: 15.1.3",""},

{"Misra C++ 2023: 15.1.5",""},

{"Misra C++ 2023: 16.5.1",""},

{"Misra C++ 2023: 16.5.2",""},

{"Misra C++ 2023: 16.6.1",""},

{"Misra C++ 2023: 17.8.1",""},

{"Misra C++ 2023: 18.1.1",""},

{"Misra C++ 2023: 18.1.2",""},

{"Misra C++ 2023: 18.3.1",""},

{"Misra C++ 2023: 18.3.2",""},

{"Misra C++ 2023: 18.3.3",""},

{"Misra C++ 2023: 18.4.1",""},

{"Misra C++ 2023: 18.5.1",""},

{"Misra C++ 2023: 18.5.2",""},

{"Misra C++ 2023: 19.0.1",""},

{"Misra C++ 2023: 19.0.2",""},

{"Misra C++ 2023: 19.0.3",""},

{"Misra C++ 2023: 19.0.4",""},

{"Misra C++ 2023: 19.1.1",""},

{"Misra C++ 2023: 19.1.2",""},

{"Misra C++ 2023: 19.1.3",""},

{"Misra C++ 2023: 19.2.1",""},

{"Misra C++ 2023: 19.2.2",""},

{"Misra C++ 2023: 19.2.3",""},

{"Misra C++ 2023: 19.3.1",""},

{"Misra C++ 2023: 19.3.2",""},

{"Misra C++ 2023: 19.3.3",""},

{"Misra C++ 2023: 19.3.4",""},

{"Misra C++ 2023: 19.6.1",""},

{"Misra C++ 2023: 21.10.1",""},

{"Misra C++ 2023: 21.10.2",""},

{"Misra C++ 2023: 21.10.3",""},

{"Misra C++ 2023: 21.2.1",""},

{"Misra C++ 2023: 21.2.2",""},

{"Misra C++ 2023: 21.2.3",""},

{"Misra C++ 2023: 21.2.4",""},

{"Misra C++ 2023: 21.6.1",""},

{"Misra C++ 2023: 21.6.2",""},

{"Misra C++ 2023: 21.6.3",""},

{"Misra C++ 2023: 21.6.4",""},

{"Misra C++ 2023: 21.6.5",""},

{"Misra C++ 2023: 22.3.1",""},

{"Misra C++ 2023: 22.4.1",""},

{"Misra C++ 2023: 23.11.1",""},

{"Misra C++ 2023: 24.5.1",""},

{"Misra C++ 2023: 24.5.2",""},

{"Misra C++ 2023: 25.5.1",""},

{"Misra C++ 2023: 25.5.2",""},

{"Misra C++ 2023: 25.5.3",""},

{"Misra C++ 2023: 26.3.1",""},

{"Misra C++ 2023: 28.3.1",""},

{"Misra C++ 2023: 28.6.1",""},

{"Misra C++ 2023: 28.6.2",""},

{"Misra C++ 2023: 30.0.1",""},

{"Misra C++ 2023: 30.0.2",""},

{"Misra C++ 2023: 4.1.1",""},

{"Misra C++ 2023: 4.1.2",""},

{"Misra C++ 2023: 5.0.1",""},

{"Misra C++ 2023: 5.10.1",""},

{"Misra C++ 2023: 5.13.1",""},

{"Misra C++ 2023: 5.13.2",""},

{"Misra C++ 2023: 5.13.3",""},

{"Misra C++ 2023: 5.13.4",""},

{"Misra C++ 2023: 5.13.5",""},

{"Misra C++ 2023: 5.13.6",""},

{"Misra C++ 2023: 5.13.7",""},

{"Misra C++ 2023: 5.7.1",""},

{"Misra C++ 2023: 5.7.2",""},

{"Misra C++ 2023: 5.7.3",""},

{"Misra C++ 2023: 6.0.1",""},

{"Misra C++ 2023: 6.0.2",""},

{"Misra C++ 2023: 6.0.3",""},

{"Misra C++ 2023: 6.0.4",""},

{"Misra C++ 2023: 6.2.2",""},

{"Misra C++ 2023: 6.2.3",""},

{"Misra C++ 2023: 6.2.4",""},

{"Misra C++ 2023: 6.4.2",""},

{"Misra C++ 2023: 6.4.3",""},

{"Misra C++ 2023: 6.5.1",""},

{"Misra C++ 2023: 6.5.2",""},

{"Misra C++ 2023: 6.7.1",""},

{"Misra C++ 2023: 6.7.2",""},

{"Misra C++ 2023: 6.8.3",""},

{"Misra C++ 2023: 6.8.4",""},

{"Misra C++ 2023: 6.9.1",""},

{"Misra C++ 2023: 6.9.2",""},

{"Misra C++ 2023: 7.0.1",""},

{"Misra C++ 2023: 7.0.2",""},

{"Misra C++ 2023: 7.0.3",""},

{"Misra C++ 2023: 7.0.4",""},

{"Misra C++ 2023: 7.0.5",""},

{"Misra C++ 2023: 7.0.6",""},

{"Misra C++ 2023: 7.11.1",""},

{"Misra C++ 2023: 7.11.2",""},

{"Misra C++ 2023: 7.11.3",""},

{"Misra C++ 2023: 8.0.1",""},

{"Misra C++ 2023: 8.1.1",""},

{"Misra C++ 2023: 8.1.2",""},

{"Misra C++ 2023: 8.14.1",""},

{"Misra C++ 2023: 8.18.2",""},

{"Misra C++ 2023: 8.19.1",""},

{"Misra C++ 2023: 8.2.1",""},

{"Misra C++ 2023: 8.2.10",""},

{"Misra C++ 2023: 8.2.11",""},

{"Misra C++ 2023: 8.2.2",""},

{"Misra C++ 2023: 8.2.3",""},

{"Misra C++ 2023: 8.2.4",""},

{"Misra C++ 2023: 8.2.5",""},

{"Misra C++ 2023: 8.2.6",""},

{"Misra C++ 2023: 8.2.7",""},

{"Misra C++ 2023: 8.2.8",""},

{"Misra C++ 2023: 8.2.9",""},

{"Misra C++ 2023: 8.20.1",""},

{"Misra C++ 2023: 8.3.1",""},

{"Misra C++ 2023: 8.3.2",""},

{"Misra C++ 2023: 9.2.1",""},

{"Misra C++ 2023: 9.3.1",""},

{"Misra C++ 2023: 9.4.1",""},

{"Misra C++ 2023: 9.4.2",""},

{"Misra C++ 2023: 9.5.1",""},

{"Misra C++ 2023: 9.5.2",""},

{"Misra C++ 2023: 9.6.1",""},

{"Misra C++ 2023: 9.6.2",""},

{"Misra C++ 2023: 9.6.3",""},

{"Misra C++ 2023: 9.6.4",""},

{"Misra C: 1.4",""},

{"Misra C: 1.5",""},

{"Misra C: 10.1",""},

{"Misra C: 10.2",""},

{"Misra C: 10.3",""},

{"Misra C: 10.4",""},

{"Misra C: 10.5",""},

{"Misra C: 10.6",""},

{"Misra C: 10.7",""},

{"Misra C: 10.8",""},

{"Misra C: 11.1",""},

{"Misra C: 11.10",""},

{"Misra C: 11.2",""},

{"Misra C: 11.3",""},

{"Misra C: 11.4",""},

{"Misra C: 11.8",""},

{"Misra C: 12.3",""},

{"Misra C: 12.6",""},

{"Misra C: 13.1",""},

{"Misra C: 13.2",""},

{"Misra C: 13.3",""},

{"Misra C: 13.4",""},

{"Misra C: 13.5",""},

{"Misra C: 13.6",""},

{"Misra C: 15.5",""},

{"Misra C: 16.3",""},

{"Misra C: 17.10",""},

{"Misra C: 17.11",""},

{"Misra C: 17.12",""},

{"Misra C: 17.13",""},

{"Misra C: 17.2",""},

{"Misra C: 17.3",""},

{"Misra C: 17.4",""},

{"Misra C: 17.9",""},

{"Misra C: 18.10",""},

{"Misra C: 18.5",""},

{"Misra C: 18.8",""},

{"Misra C: 18.9",""},

{"Misra C: 20.3",""},

{"Misra C: 21.1",""},

{"Misra C: 21.12",""},

{"Misra C: 21.16",""},

{"Misra C: 21.2",""},

{"Misra C: 21.20",""},

{"Misra C: 21.22",""},

{"Misra C: 21.23",""},

{"Misra C: 21.24",""},

{"Misra C: 21.25","warning"},

{"Misra C: 21.26","warning"},

{"Misra C: 22.11",""},

{"Misra C: 22.12",""},

{"Misra C: 22.13",""},

{"Misra C: 22.14",""},

{"Misra C: 22.15",""},

{"Misra C: 22.16","warning"},

{"Misra C: 22.17","warning"},

{"Misra C: 22.18","warning"},

{"Misra C: 22.19","warning"},

{"Misra C: 22.20",""},

{"Misra C: 23.1",""},

{"Misra C: 23.2",""},

{"Misra C: 23.3",""},

{"Misra C: 23.4",""},

{"Misra C: 23.5",""},

{"Misra C: 23.6",""},

{"Misra C: 23.7",""},

{"Misra C: 23.8",""},

{"Misra C: 5.1",""},

{"Misra C: 5.2",""},

{"Misra C: 6.1",""},

{"Misra C: 6.3",""},

{"Misra C: 7.4","style"},

{"Misra C: 7.5",""},

{"Misra C: 7.6",""},

{"Misra C: 8.1",""},

{"Misra C: 8.10",""},

{"Misra C: 8.15",""},

{"Misra C: 8.15",""},

{"Misra C: 8.16",""},

{"Misra C: 8.17",""},

{"Misra C: 8.3",""},

{"Misra C: 8.4",""},

{"Misra C: 8.6",""},

{"Misra C: 8.7",""},

{"Misra C: 8.8",""},

{"Misra C: 9.6",""},

{"Misra C: 9.7",""},

{"Misra C: Dir 4.3",""},

{"Misra C: Dir 4.4",""},

{"Misra C: Dir 4.5",""},

{"Misra C: Dir 4.6",""},

{"Misra C: Dir 4.9",""},

{"PremiumCheckBufferOverrun::addressOfPointerArithmetic","warning"},

{"PremiumCheckBufferOverrun::negativeBufferSizeCheckedNonZero","warning"},

{"PremiumCheckBufferOverrun::negativeBufferSizeCheckedNonZero","warning"},

{"PremiumCheckHang::infiniteLoop",""},

{"PremiumCheckHang::infiniteLoopContinue",""},

{"PremiumCheckOther::arrayPointerComparison","style"},

{"PremiumCheckOther::knownResult","style"},

{"PremiumCheckOther::lossOfPrecision","style"},

{"PremiumCheckOther::pointerCast","style"},

{"PremiumCheckOther::reassignInLoop","style"},

{"PremiumCheckOther::unreachableCode","style"},

{"PremiumCheckStrictAlias::strictAliasCondition","warning"},

{"PremiumCheckUninitVar::uninitmember",""},

{"PremiumCheckUninitVar::uninitvar",""},

{"PremiumCheckUnusedVar::unreadVariable","style"},

{"PremiumCheckUnusedVar::unusedPrivateMember","style"}

};

const char Req[] = "Required";

const char Adv[] = "Advisory";

const char Man[] = "Mandatory";

const char Doc[] = "Document";

const std::vector<MisraInfo> misraC2012Directives =

{

{1,1,Req,0},

{2,1,Req,0},

{3,1,Req,0},

{4,1,Req,0},

{4,2,Adv,0},

{4,3,Req,0},

{4,4,Adv,0},

{4,5,Adv,0},

{4,6,Adv,3},

{4,7,Req,0},

{4,8,Adv,0},

{4,9,Adv,3},

{4,10,Req,0},

{4,11,Req,3},

{4,12,Req,0},

{4,13,Adv,0},

{4,14,Req,2},

{4,15,Req,3},

{5,1,Req,4},

{5,2,Req,4},

{5,3,Req,4},

};

const std::vector<MisraInfo> misraC2012Rules =

{

{1,1,Req,0},

{1,2,Adv,0},

{1,3,Req,0},

{1,4,Req,2}, // amendment 2

{1,5,Req,3}, // Amendment 3

{2,1,Req,0},

{2,2,Req,0},

{2,3,Adv,0},

{2,4,Adv,0},

{2,5,Adv,0},

{2,6,Adv,0},

{2,7,Adv,0},

{2,8,Adv,0},

{3,1,Req,0},

{3,2,Req,0},

{4,1,Req,0},

{4,2,Adv,0},

{5,1,Req,0},

{5,2,Req,0},

{5,3,Req,0},

{5,4,Req,0},

{5,5,Req,0},

{5,6,Req,0},

{5,7,Req,0},

{5,8,Req,0},

{5,9,Adv,0},

{6,1,Req,0},

{6,2,Req,0},

{6,3,Req,0},

{7,1,Req,0},

{7,2,Req,0},

{7,3,Req,0},

{7,4,Req,0},

{7,5,Man,0},

{7,6,Req,0},

{8,1,Req,0},

{8,2,Req,0},

{8,3,Req,0},

{8,4,Req,0},

{8,5,Req,0},

{8,6,Req,0},

{8,7,Adv,0},

{8,8,Req,0},

{8,9,Adv,0},

{8,10,Req,0},

{8,11,Adv,0},

{8,12,Req,0},

{8,13,Adv,0},

{8,14,Req,0},

{8,15,Req,0},

{8,16,Adv,0},

{8,17,Adv,0},

{9,1,Man,0},

{9,2,Req,0},

{9,3,Req,0},

{9,4,Req,0},

{9,5,Req,0},

{9,6,Req,0},

{9,7,Man,0},

{10,1,Req,0},

{10,2,Req,0},

{10,3,Req,0},

{10,4,Req,0},

{10,5,Adv,0},

{10,6,Req,0},

{10,7,Req,0},

{10,8,Req,0},

{11,1,Req,0},

{11,2,Req,0},

{11,3,Req,0},

{11,4,Adv,0},

{11,5,Adv,0},

{11,6,Req,0},

{11,7,Req,0},

{11,8,Req,0},

{11,9,Req,0},

{11,10,Req,0},

{12,1,Adv,0},

{12,2,Req,0},

{12,3,Adv,0},

{12,4,Adv,0},

{12,5,Man,1}, // amendment 1

{12,6,Req,4}, // amendment 4

{13,1,Req,0},

{13,2,Req,0},

{13,3,Adv,0},

{13,4,Adv,0},

{13,5,Req,0},

{13,6,Man,0},

{14,1,Req,0},

{14,2,Req,0},

{14,3,Req,0},

{14,4,Req,0},

{15,1,Adv,0},

{15,2,Req,0},

{15,3,Req,0},

{15,4,Adv,0},

{15,5,Adv,0},

{15,6,Req,0},

{15,7,Req,0},