CodeCheck Documentation
CodeCheck Documentation - Uncategorized Checks

Uncategorized Checks

Check IDCheck NameSupportedSeverity
AC_00No Control Code CharactersYes
AC_01No Direct or Indirect RecursionYes
AC_HIS_02Number of Paths(PATH)Yes
AC_HIS_04Cyclomatic Complexity (v(G))Yes
AC_HIS_05Calling Functions (CALLING)Yes
AC_HIS_06Called Functions (CALLS)Yes
AC_HIS_07Function Parameters (PARAM)Yes
AC_HIS_08Number of Staments (STMT)Yes
AC_HIS_09Number of call levels (LEVEL)Yes
AC_HIS_10Number of return points (RETURN)Yes
AC_HIS_11Language scope (VOCF)Yes
AC_HIS_12Recursion (AP_CG_CYCLE)Yes
AC_HIS_13Statements Changed (SCHG)Yes
AC_HIS_14Statements Deleted (SDEL)Yes
AC_HIS_15New Statements (SNEW)Yes
AC_HIS_16Stability Index (S)Yes
ADA_N000Naming Convention: ComponentsYes
ADA_N001Naming Convention: EntriesYes
ADA_N002Naming Convention: EnumerationsYes
ADA_N003Naming Convention: ExceptionsYes
ADA_N004Naming Convention: FilesYes
ADA_N005Naming Convention: FunctionsYes
ADA_N006Naming Convention: ImplicitsYes
ADA_N007Naming Convention: ObjectsYes
ADA_N008Naming Convention: PackagesYes
ADA_N009Naming Convention: ParametersYes
ADA_N010Naming Convention: ProceduresYes
ADA_N011Naming Convention: Protected EntitiesYes
ADA_N012Naming Convention: TasksYes
ADA_N013Naming Convention: TypesYes
ADA_V000Unused VariablesYes
ADA_V001Variables should be commentedYes
ADA_V002Magic NumbersYes
ARR39-CDo not add or subtract a scaled integer to a pointerYesHigh
CC_PLUG_DUPLICATESDuplicate Lines of CodeYesInformational
CC_PLUG_FILE_DUPLICATESFile Duplicate Lines of CodeYesInformational
CPP_A000Assembler instructions only use asm keywordYes
CPP_A001Assembly language shall be encapsulated and isolated.Yes
CPP_A002Assignment Operator Return ThisYes
CPP_A003Assignment Operator Self AssignmentYes
CPP_A004Parameter of assignment operator is a constant referenceYes
CPP_A005Move and copy assignment operators shall either move or respectively copy base classes and data members of a class, without any side effectsYes
CPP_A006The asm declaration shall not be used.Yes
CPP_A007Assembler instructions shall only be introduced using the asm declaration.Yes
CPP_A008Assembly Language Code Usage not DocumentedYes
CPP_A009User-defined copy and move assignment operators should use user-defined no-throw swap function.Yes
CPP_A010Move constructor shall not initialize its class members and base classes using copy semantics.Yes
CPP_A011A copy assignment and a move assignment operators shall handle self-assignment.Yes
CPP_A012Copy and move constructors and copy assignment and move assignment operators shall be declared protected or defined "=delete" in base class.Yes
CPP_A013Assignment operators should be declared with the ref-qualifier &.Yes
CPP_A014The semantic equivalence between a binary operator and its assignment operator form shall be preservedYes
CPP_A015An assignment operator shall return a reference to "this"Yes
CPP_A016In a class template with a dependent base, any name that may be found in that dependent base shall be referred to using a qualified-id or this->Yes
CPP_A017A template should check if a specific template argument is suitable for this templateYes
CPP_AO000Assignment operators shall not be used in sub-expressionsYes
CPP_B000Bool, Unsigned, or Signed Bit-fieldsYes
CPP_B001( Fuzzy parser ) Bit-fields shall only be declared with an appropriate typeYes
CPP_B002Enum Bit-fieldsYes
CPP_B003The underlying bit representations of floating-point values shall not be usedYes
CPP_B004( Fuzzy parser ) Named bit-fields with signed integer type shall have a length of more than one bit.Yes
CPP_B005( Fuzzy parser ) Single-bit named bit fields shall not be of a signed typeYes
CPP_B006Bit-field LengthYes
CPP_C000Commented Out CodeYes
CPP_C001Line-splicing shall not be used in // commentsYes
CPP_C002No Nested CommentsYes
CPP_C003Only use /* commentsYes
CPP_C004Parameter of copy constructor is a constant referenceYes
CPP_C005Members in function-try-blocks in constructors or destructorsYes
CPP_C006Explicitly call all immediate and virtual base classesYes
CPP_C007A copy constructor shall be declared when there is a template constructor with a single parameter that is a generic parameterYes
CPP_C008A copy constructor shall only initialize its base classes and the non-static members of the class of which it is a memberYes
CPP_C009Explicit ConstructorsYes
CPP_C010Incomplete constructor initialization listYes
CPP_C011An object's dynamic type shall not be used from the body of its constructor or destructorYes
CPP_C012Virtual Function Call In ConstructorYes
CPP_C013The statement forming the body of a switch, while, do ... while or for statement shall be a compound statementYes
CPP_C014Dangling ElseYes
CPP_C015A for loop shall contain a single loop-counter which shall not have floating-point typeYes
CPP_C016An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statementYes
CPP_C017The body of an iteration-statement or a selection-statement shall be a compound-statement Yes
CPP_C018Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statementYes
CPP_C019A loop-control-variable other than the loop-counter shall not be modified within condition or expressionYes
CPP_C020If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <=, <, > or >=Yes
CPP_C021The loop-counter shall be modified by one of: --, ++, -= n, or += n; where n remains constant for the duration of the loopYes
CPP_C022The loop-counter shall not be modified within condition or statementYes
CPP_C023The goto statement shall jump to a label declared later in the same function bodyYes
CPP_C024No Continue StatementsYes
CPP_C025Goto StatementsYes
CPP_C026 There should be no more than one break or goto statement used to terminate any iteration statementYes
CPP_C027Member data in non-POD class types shall be privateYes
CPP_C028A null statement shall only occur on a line by itselfYes
CPP_C029Single exit point at endYes
CPP_C030A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYes
CPP_C031Switch Has DefaultYes
CPP_C032 Every switch statement shall have at least two switch-clausesYes
CPP_C033An unconditional throw or break statement shall terminate every non-empty switch-clauseYes
CPP_C034Unreachable CodeYes
CPP_C035No Backslash at End of CommentYes
CPP_C036If statements shall not have assignments in the conditionsYes
CPP_C037DocumentationYes
CPP_C038Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided that the first character following the null statement is a white-space characterYes
CPP_C039A switch statement shall have at least two case-clauses, distinct from the default labelYes
CPP_C040A loop-control-variable other than the loop-counter which is modified in statement shall have type boolYes
CPP_C041Do statements should not be usedYes
CPP_C042For-init-statement and expression should not perform actions other than loop-counter initialization and modificationYes
CPP_C043Checked exceptions that could be thrown from a function shall be specified together with the function declaration and they shall be identical in all function declarations and for all its overriders.Yes
CPP_C044Continue Statement Used in a not Well-formed For LoopYes
CPP_C045Write constructor member initializers in the canonical orderYes
CPP_C046Switch Statement not Well-formedYes
CPP_C047All if and else if constructs shall be terminated with an else clauseYes
CPP_C049Class Constructor with Parameter Type std::initializer_listYes
CPP_C050A for-loop that loops through all elements of the container and does not use its loop-counter shall not be usedYes
CPP_C051Constructors that are not noexcept shall not be invoked before program startupYes
CPP_C052If a constructor is not noexcept and the constructor cannot finish object initialization, then it shall deallocate the object's resources and it shall throw an exceptionYes
CPP_C053Explicit Calls to Constructors of Temporary ObjectsYes
CPP_C054When a "deep copy" constructor is not implemented, comments in the class header shall describe this factYes
CPP_C055Constructors that can be used with one argument should be declared explicit.Yes
CPP_C056Move and copy constructors shall move and respectively copy base classes and data members of a class, without any side effectsYes
CPP_CF000The condition of a switch statement shall not have bool typeYes
CPP_CF001All cases in a switch statement shall have a break or it shall be well commentedYes
CPP_CF002Switch statements should have a default caseYes
CPP_CF003Switch label unstructuredYes
CPP_CF004The std::terminate() function shall not be called implicitlyYes
CPP_CF005Program shall not be abruptly terminatedYes
CPP_CF006Simple Control FlowYes
CPP_CF007Loops with Fixed LimitsYes
CPP_CM000Comments shall precede code being commented and shall align with code they representYes
CPP_CM001Each function shall end with a commentYes
CPP_CM002Timing delays shall be preceded by comments explaining the delayYes
CPP_CM003Class headers shall include a short description for every member function declaration and a comment for every data member declaredYes
CPP_CT_BUGPRONE_ASSERT_SIDE_EFFECTAssert Side EffectYesHigh
CPP_CT_BUGPRONE_BRANCH_CLONEBranch CloneYesHigh
CPP_CT_BUGPRONE_COPY_CONSTRUCTOR_INITCopy Constructor InitYesHigh
CPP_CT_BUGPRONE_INFINITE_LOOPInfinte LoopYesHigh
CPP_CT_BUGPRONE_MACRO_REPEATED_SIDE_EFFECTSMacro Side EffectsYesHigh
CPP_CT_BUGPRONE_NOT_NULL_TERMINATED_RESULTMissing Null TerminatorYesHigh
CPP_CT_BUGPRONE_REDUNDANT_BRANCH_CONDITIONRedundant ConditionYesHigh
CPP_CT_MODERNIZE_USE_DEFAULT_MEMBER_INITDefault Member InitYes
CPP_CT_MODERNIZE_USE_EQUALS_DEFAULTDefault Member FunctionYes
CPP_CT_MODERNIZE_USE_EQUALS_DELETEDelete Member FunctionYes
CPP_CT_MODERNIZE_USE_NULLPTRNull Pointer KeywordYes
CPP_CT_READABILITY_DELETE_NULL_POINTERDelete Null PointerYesHigh
CPP_CT_READABILITY_REDUNDANT_CASTINGRedundant CastYesHigh
CPP_D000An accessible base class shall not be both virtual and non-virtual in the same hierarchyYes
CPP_D001Do not delete a polymorphic object without a virtual destructorYes
CPP_D002Single DeclarationsYes
CPP_D003When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisationYes
CPP_D004A u or U suffix shall be applied to all integer constants that are represented in an unsigned typeYes
CPP_D005A base class shall only be declared virtual if it is used in a diamond hierarchyYes
CPP_D006Class Derived From Virtual BasesYes
CPP_D007A compatible declaration shall be visible when an object or function with external linkage is definedYes
CPP_D008A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a generic parameterYes
CPP_D009Multiple declarations for an identifier in the same namespace shall not straddle a using-declaration for that identifierYes
CPP_D010= construct in enumerator list shall only be used on either the first item alone, or all items explicitly.Yes
CPP_D011Use the static keyword for internal linkageYes
CPP_D012An external object or function shall be declared in one and only one fileYes
CPP_D013An identifier with external linkage shall have exactly one definitionYes
CPP_D015Externals shall have the same type in the declaration and definitionYes
CPP_D017Non-static Inline FunctionsYes
CPP_D018Literal suffixes shall be upper caseYes
CPP_D019The comma operator, && operator and the || operator shall not be overloadedYes
CPP_D020The lowercase character L shall not be used in a literal suffixYes
CPP_D021Narrow and wide string literals shall not be concatenatedYes
CPP_D022Functions and objects should not be defined with external linkage if they are referenced in only one translation unitYes
CPP_D023Single-Function Global ObjectsYes
CPP_D024The restrict type qualifier shall not be usedYes
CPP_D026The register keyword shall not be usedYes
CPP_D027The unary & operator shall not be overloadedYes
CPP_D028Within an enumerator list, the value of an implicitly-specified enumeration constant shall be uniqueYes
CPP_D029Destructor Set Data Ptr to 0Yes
CPP_D030Exceptions in DestructorsYes
CPP_D031Non-Virtual Destructors in Base ClassesYes
CPP_D032Virtual Function Call In DestructorYes
CPP_D033A function shall not be declared implicitlyYes
CPP_D034Datamembers should be declared privateYes
CPP_D035Destructor of a base class shall be public virtual, public override or protected non-virtualYes
CPP_D036Volatile keyword shall not be usedYes
CPP_D037Functions shall not be declared at block scopeYes
CPP_D038When an array with external linkage is declared, its size shall be stated explicitlyYes
CPP_D039A function definition shall only be placed in a class definition if (1) the function is intended to be inlined (2) it is a member function template (3) it is a member function of a class templateYes
CPP_D040All declarations of an object or function shall have compatible typesYes
CPP_D041The One Definition RuleYes
CPP_D042If a function has internal linkage then all redeclarations shall include the static storage class specifierYes
CPP_D043Static and thread-local objects shall be constant-initializedYes
CPP_D044Declarations at Lowest ScopeYes
CPP_D045A type, object or function that is used in multiple translation units shall be declared in one and only one fileYes
CPP_D046Constexpr or const specifiers shall be used for immutable data declarationYes
CPP_D047The constexpr specifier shall be used for values that can be determined at compile timeYes
CPP_D048The auto specifier shall not be used apart from following cases: (1) to declare that a variable has the same type as return type of a function call, (2) to declare that a variable has the same type as initializer of non-fundamental type, (3) to declare parameters of a generic lambda expression, (4) to declare a function template using trailing return type syntaxYes
CPP_D049A class, structure, or enumeration shall not be declared in the definition of its typeYes
CPP_D050Enumerations shall be declared as scoped enum classesYes
CPP_D051A non-type specifier shall be placed before a type specifier in a declaration.Yes
CPP_D052Use the same identifier in definition and declaration of functions.Yes
CPP_D053Multiple Base ClassesYes
CPP_D054Virtual function declaration shall contain exactly one of the three specifiers: (1) virtual, (2) override, (3) finalYes
CPP_D055All Checks/Language Specific/C and C++/Destructors/Non-Virtual Destructors in Base ClassesYes
CPP_D056User-defined assignment operator shall not be virtualYes
CPP_D057Hierarchies should be based on interface classesYes
CPP_D058A non-POD type should be defined as classYes
CPP_D059Friend declarations shall not be used.Yes
CPP_D060If a class declares a copy or move operation, or a destructor, either via "=default", "=delete", or via a user-provided declaration, then all others of these five special member functions shall be declared as well.Yes
CPP_D061Constructors shall explicitly initialize all virtual base classes, all direct non-virtual base classes and all non-static data members.Yes
CPP_D062Both NSDMI and a non-static member initializer in a constructor shall not be used in the same type.Yes
CPP_D063If all user-defined constructors of a class initialize data members with constant values that are the same across all constructors, then data members shall be initialized using NSDMI instead.Yes
CPP_D064All constructors that are callable with a single argument of fundamental type shall be declared explicit.Yes
CPP_D065Common class initialization for non-constant members shall be done by a delegating constructor.Yes
CPP_D066If a public destructor of a class is non-virtual, then the class should be declared final.Yes
CPP_D067All class data members that are initialized by the constructor shall be initialized using member initializers.Yes
CPP_D068If the behavior of a user-defined special member function is identical to implicitly defined special member function, then it shall be defined =default or be left undefined.Yes
CPP_D069Member Data in Non-POD Class not PrivateYes
CPP_D070Template specialization shall be declared in the same file as the primary templateYes
CPP_D071All user-provided class destructors, deallocation functions, move constructors, move assignment operators and swap functions shall not exit with an exception. A noexcept exception specification shall be added to these functions as appropriateYes
CPP_D072Non-standard entities shall not be added to standard namespacesYes
CPP_D073There shall be one variable declaration per line Yes
CPP_D074An external variable shall not be set to a value where it is being declaredYes
CPP_D075Incorrect Order of InitializationYes
CPP_D076If a class requires a virtual destructor but has nothing to undo from a constructor, an empty implementation should be provided.Yes
CPP_DD000The defines, typedefs, structures, externals, globals, statics, external prototypes, and local prototypes shall be grouped by category.Yes
CPP_DD001Use of global functions and variables shall be limitedYes
CPP_DD002Globals should not be used in macrosYes
CPP_DD003There shall be a function prototype for all functionsYes
CPP_DD004Prototypes for static functions shall include the static storage classYes
CPP_DD005Any defined constants that are used as argument or return variables shall be placed in an include fileYes
CPP_DD006Initializer lists shall be written in the order in which they are declaredYes
CPP_DD007The private keyword should be used in class definitionsYes
CPP_DD008Nesting template class definitions should be avoided.Yes
CPP_DD009Assignment operators should check for self-assignmentYes
CPP_DD010The use of friend classes should be avoidedYes
CPP_DD011If the subscript operator (operator[]) is overloaded, both the const and non-const versions should be defined.Yes
CPP_DD012Layering techniques, where applicable, should be used instead of private inheritance.Yes
CPP_DD013Public Inheritance not Used in a "is-a" RelationshipYes
CPP_DD014Use the same parameter names and type qualifiers for all declarations and definitionsYes
CPP_DD015Overload allocation and deallocation functions as a pair in the same scopeYes
CPP_DD016Do not write syntactically ambiguous declarationsYes
CPP_DD017Avoid cycles during initialization of static objectsYes
CPP_DD018Obey the one-definition ruleYes
CPP_DD019Arrays shall not be partially initializedYes
CPP_DD020An element of an object shall not be initialized more than onceYes
CPP_DD021Where designated initializers are used to initialize an array object the size of the array shall be specified explicitlyYes
CPP_DD022Make sure that objects are initialized before they are usedYes
CPP_DD023Use the same form in corresponding uses of new and deleteYes
CPP_DD024Postpone variable definitions as long as possibleYes
CPP_DD025Avoid hiding inherited namesYes
CPP_DD026Never redefine an inherited non-virtual functionYes
CPP_E000A class type exception shall always be caught by referenceYes
CPP_E001There should be at least one exception handler to catch all otherwise unhandled exceptionsYes
CPP_E002Catch-All Statement Before LastYes
CPP_E003Catch Const ReferencesYes
CPP_E004Destructors Not Throw ExceptionsYes
CPP_E005An empty throw (throw;) shall only be used in the compound-statement of a catch handlerYes
CPP_E006Order of Catch Blocks with Derived ClassesYes
CPP_E007An exception object should not have pointer typeYes
CPP_E008Exceptions shall be raised only after start-up and before termination of the programYes
CPP_E009Exceptions thrown shall be the type indicated by the functionYes
CPP_E010Inconsistent Exception-SpecificationYes
CPP_E011No "errno" allowedYes
CPP_E012NULL shall not be thrown explicitlyYes
CPP_E013Throw exceptions by value, not by pointerYes
CPP_E014The assignment-expression of a throw statement shall not itself cause an exception to be thrownYes
CPP_E015Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the logical operators &&, ||, !, the equality operators == and !=, the unary & operator, and the conditional operatorYes
CPP_E016Character OperatorsYes
CPP_E017Code Slicing Should Not OccurYes
CPP_E018Expressions with type enum or enum class shall not be used as operands to built-in and overloaded operators other than the subscript operator [ ], the assignment operator =, the equality operators == and ! =, the unary & operator, and the relational operators <, <=, >, >=Yes
CPP_E019Avoid TrigraphsYes
CPP_E020Octal constants (other than zero) and octal escape sequences (other than "\0" ) shall not be used.Yes
CPP_E021Octal and Hexadecimal SequencesYes
CPP_E022Escape sequences are standardizedYes
CPP_E023Expression uses operand of side-effect more than onceYes
CPP_E024Signed operands to modulus or division operatorYes
CPP_E025Floating Equality TestYes
CPP_E026Minimization of run-time failures shall be ensured by the use of static analysis toolsYes
CPP_E027Only those escape sequences that are defined in ISO/IEC 14882:2014 shall be usedYes
CPP_E028Hexadecimal constants should be upper caseYes
CPP_E029A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type.Yes
CPP_E031Traditional C-style casts shall not be usedYes
CPP_E032Infeasible PathsYes
CPP_E033Do not rely on the value of a moved-from objectYes
CPP_E034Limited dependence should be placed on C++ operator precedence rules in expressionsYes
CPP_E035Parameter list (possibly empty) shall be included in every lambda expressionYes
CPP_E036Specify Lambda Return TypeYes
CPP_E037Lambda expressions should not be defined inside another lambda expressionYes
CPP_E038Identical unnamed lambda expressions shall be replaced with a named function or a named lambda expressionYes
CPP_E039A lambda shall not be an operand to decltype or typeidYes
CPP_E040dynamic_cast should not be usedYes
CPP_E041reinterpret_cast shall not be usedYes
CPP_E042Operands of Logical Boolean OperatorsYes
CPP_E043The increment (++) and decrement (--) operators shall not be mixed with other operators in an expressionYes
CPP_E044Each operand of the ! operator, the logical && or the logical || operators shall have type boolYes
CPP_E045Evaluation of the operand to the sizeof operator shall not contain side effectsYes
CPP_E046The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left hand operand.Yes
CPP_E047The ternary conditional operator shall not be used as a sub-expressionYes
CPP_E048Each expression statement and identifier declaration shall be placed on a separate lineYes
CPP_E049The comma operator shall not be used.Yes
CPP_E050AEvaluation of the operand to the typeid operator shall not contain side effectsYes
CPP_E050BThe right hand operand of the integer division or remainder operators shall not be equal to zeroYes
CPP_E051Unary Minus Operator Applied to an Expression with an Unsigned TypeYes
CPP_E052The right-hand operand of a logical && or || operator should not contain persistent side effectsYes
CPP_E053Empty ThrowYes
CPP_E054NULL ThrowYes
CPP_E055Exception ObjectYes
CPP_E056A lambda expression object shall not outlive any of its reference-captured objectsYes
CPP_E057Only instances of types derived from std::exception should be thrownYes
CPP_E058An exception object shall not be a pointerYes
CPP_E059All thrown exceptions should be uniqueYes
CPP_E060If a function exits with an exception, then before a throw, the function shall place all objects/resources that the function constructed in valid states or it shall delete themYes
CPP_E061Dynamic exception-specification shall not be usedYes
CPP_E062A class type exception shall be caught by reference or const referenceYes
CPP_E063Catch-all (ellipsis and std::exception) handlers shall be used only in (a) main, (b) task main functions, (c) in functions that are supposed to isolate independent components and (d) when calling third-party code that uses exceptions not according to AUTOSAR C++14 guidelinesYes
CPP_E064Unhandled Exceptions on Main FunctionYes
CPP_E065Condition of if statement shall be boolYes
CPP_E066Const Should be placed on the left-hand side of the comparisonYes
CPP_E067Floats shall not be tested for direct equalityYes
CPP_E068Provide a valid ordering predicateYes
CPP_E069Assignment in SubExpressionsYes
CPP_E070Boolean operatorsYes
CPP_E072Int to Float ConversionYes
CPP_E073An implicit integral conversion shall not change the signedness of the underlying typeYes
CPP_E074Operands shall not be of an inappropriate essential typeYes
CPP_E075Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type categoryYes
CPP_E077The value of a composite expression shall not be assigned to an object with wider essential typeYes
CPP_E078The value of a composite expression shall not be cast to a different essential type category or a wider essential typeYes
CPP_E079Conversions shall not be performed between a pointer to an incomplete type and
any other type
Yes
CPP_E080A cast shall not be performed between a pointer to object type and a pointer to a different object typeYes
CPP_E081 A conversion should not be performed between a pointer to object and an integer typeYes
CPP_E082Initializer lists shall not contain persistent side effectsYes
CPP_E083The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essentially Boolean typeYes
CPP_E084The macro NULL shall be the only permitted form of integer null pointer constantYes
CPP_E085The result of an assignment operator should not be usedYes
CPP_E086A loop counter shall not have essentially floating typeYes
CPP_E087Minimize castingYes
CPP_EH000Program shall not be abruptly terminatedYes
CPP_EH001The std::terminate() function shall not be called implicitlyYes
CPP_EH002Library objects shall not generate error messages directlyYes
CPP_EH003Destructors should not throw exceptionsYes
CPP_EH004Exceptions should be caught only by referenceYes
CPP_EH005A declaration of non-throwing function shall contain noexcept specificationYes
CPP_EH006If a function is declared to be noexcept, noexcept(true) or noexcept(<truecondition>), then it shall not exit with an exceptionYes
CPP_EH007Each exception explicitly thrown in the code shall have a handler of a compatible type in all call paths that could lead to that pointYes
CPP_EH008Exceptions thrown across execution boundariesYes
CPP_EH009New Method Throwing an ExceptionYes
CPP_EH010Use Assertion StatementsYes
CPP_EH011Catch exceptions by lvalue referenceYes
CPP_F000All prototype parameters must have an identifier.Yes
CPP_F001All class templates, function templates, class template member functions and class template static members shall be instantiated at least onceYes
CPP_F002Const member functions shall not return non-const pointers or references to class-dataYes
CPP_F003Unused FunctionsYes
CPP_F004Functions with no parameters need explicit void keywordYes
CPP_F005Declare functions at file scopeYes
CPP_F006A Function identifier shall either be used to call the function or it shall be preceded by &Yes
CPP_F007Functions must not return objects by value.Yes
CPP_F008Functions shall not be defined using the ellipsis notationYes
CPP_F009Use Named Parameters and Prototype FormYes
CPP_F010Functions shall not be declared implicitlyYes
CPP_F011Inline functions defined in the class bodyYes
CPP_F012The identifier main shall not be used for a function other than the global function mainYes
CPP_F013Member functions shall not return non-const handles to class-dataYes
CPP_F014If a member function can be made static then it shall be made static, otherwise if it can be made const then it shall be made constYes
CPP_F015Missing parameter name in function declarationsYes
CPP_F016variable numbers of arguments shall not be used.Yes
CPP_F017Overloaded function templates shall not be explicitly specializedYes
CPP_F018Parameters in an overriding virtual function shall either use the same default arguments as the function they override, or else shall not specify any default arguments.Yes
CPP_F019A pointer or reference parameter in a function shall be declared as pointer to const or reference to const if the corresponding object is not modifiedYes
CPP_F020use the same identifier in definition and declaration of functions.Yes
CPP_F021The features of <stdarg.h> shall not be usedYes
CPP_F022Objects should not be passed by referenceYes
CPP_F023A function parameter should not be modifiedYes
CPP_F024The value returned by a function shall be usedYes
CPP_F025All functions with void return type shall have external side effect(s)Yes
CPP_F026Every function defined in an anonymous namespace, or static function with internal linkage, or private member function shall be usedYes
CPP_F027There shall be no unused named parameters in non-virtual functionsYes
CPP_F028There shall be no unused named parameters in the set of parameters for a virtual function and all the functions that override itYes
CPP_F029operator "new" and operator "delete" shall be defined togetherYes
CPP_F030If a project has a sized or unsized version of operator "delete" globally defined, then both sized and unsized versions shall be definedYes
CPP_F031A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the function.Yes
CPP_F032A function shall not return a reference or a pointer to a parameter that is passed by reference to const.Yes
CPP_F033Always return a value in non-void functionsYes
CPP_F034Trivial accessor and mutator functions should be inlined.Yes
CPP_F035Non-virtual public or protected member functions shall not be redefined in derived classesYes
CPP_F036Use OverrideYes
CPP_F037Time Handling Functions of <ctime>Yes
CPP_F038Check Parameters and Return Values - Unchecked Parameters and Return ValuesYes
CPP_F038_ACheck Parameters and Return Values - Ignored Return ValuesYes
CPP_F039A function that contains "forwarding reference" as its argument shall not be overloadedYes
CPP_F040A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYes
CPP_F041Member functions shall not return non-const raw pointers or references to private or protected data owned by the classYes
CPP_F042If two opposite operators are defined, one shall be defined in terms of the otherYes
CPP_F043Comparison operators shall be non-member functions with identical parameter types and noexceptYes
CPP_F044Overloaded Function Not Visible From Where it is CalledYes
CPP_F045Virtual functions shall not be introduced in a final classYes
CPP_F046Predicate Function Objects Copied IncorrectlyYes
CPP_F047A template constructor shall not participate in overload resolution for a single argument of the enclosing class typeYes
CPP_F048A non-member generic operator shall only be declared in a namespace that does not contain class (struct) type, enum type or union type declarationsYes
CPP_F049Explicit specializations of function templates shall not be usedYes
CPP_F050The noexcept specification of a function shall either be identical across all translation units, or identical or more restrictive between a virtual member function and an overriderYes
CPP_F051A function should be inlined only if it has one or two lines of codeYes
CPP_F052The function gets() should not be usedYes
CPP_F053Every function shall have an explicitly declared return type.Yes
CPP_F054Boolean functions shall explicitly return true or falseYes
CPP_F055The default parameter list, when redeclaring or overriding methods, should be kept constantYes
CPP_F056Each function shall contain a prologueYes
CPP_F057Function prologue shall be in header or sourceYes
CPP_F058Function prologue shall contain certain specific informationYes
CPP_F059Variable-length argument lists should not be usedYes
CPP_F060A method that does not change the visible properties of a class shall be declared constYes
CPP_F061The type of the return and all method arguments (even type void) shall be specified when defining a methodYes
CPP_F062When overloading standardized operators (e.g., a += b, a-=b etc.), the resulting behavior should remain consistent with the expected outcome of the operator.Yes
CPP_F063Member function arguments should not share the same name as class state variablesYes
CPP_F064Member functions should always be declared const unless they modify state variablesYes
CPP_F065Any parameter not modified by a method should be passed to the method as a const.Yes
CPP_F066Tail-Call OptimizationYes
CPP_F067Functions declared with the [[noreturn]] attribute shall not returnYes
CPP_F069A signal handler must be a plain old functionYes
CPP_F070Consider alternatives to virtual functionsYes
CPP_H000The #include directive shall be followed by either a <filename> or "filename" sequenceYes
CPP_H001The backslash character should not occur in a header file nameYes
CPP_H002The ', ", /* or // characters shall not occur in a header file nameYes
CPP_H003Definitions in Header FilesYes
CPP_H004There shall be no unnamed namespaces in header files.Yes
CPP_H005Objects or functions with external linkage shall be declared in a header fileYes
CPP_H006It shall be possible to include any header file in multiple translation units without violating the One Definition RuleYes
CPP_H007Unnecessary #IncludesYes
CPP_H008using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used in header files.Yes
CPP_H009Header files, that are defined locally in the project, shall have a file name extension of one of: ".h", ".hpp" or ".hxx"Yes
CPP_H010Header File NameYes
CPP_H011Absolute path names shall not be used for header filesYes
CPP_H012All references to header files shall be listed one per lineYes
CPP_H013Names of private header files should not be identical to names of library header filesYes
CPP_H014All public header files shall be capable of being included by a C++ file as well as a C fileYes
CPP_H016If prototypes, typedefs, macros, structure definitions, or enums are needed in multiple modules, they shall be placed in header filesYes
CPP_H017C++ version of the header file should be usedYes
CPP_H018When including C Standard Library header files, C++ Standard Library header files without a '.h' appended should be usedYes
CPP_H019Forward referencing should be used, when appropriate, over direct inclusion when documenting dependencies within a header file.Yes
CPP_H020The standard header file <tgmath.h> shall not be usedYes
CPP_H021The standard header file <setjmp.h> shall not be usedYes
CPP_I000A class, union or enum name (including qualification, if any) shall be a unique identifierYes
CPP_I001Different identifiers shall be typographically unambiguousYes
CPP_I002External identifiers shall be distinctYes
CPP_I003Identifiers that define objects or functions with external linkage shall be uniqueYes
CPP_I004Global Namespace DeclarationsYes
CPP_I005Identifier name reuseYes
CPP_I006Identifiers shall be distinct from macro namesYes
CPP_I007Identifiers declared in the same scope and name space shall be distinctYes
CPP_I008Identifiers that define objects or functions with internal linkage should be uniqueYes
CPP_I009Macro identifiers shall be distinctYes
CPP_I010The identifier name of a non-member object or function with static storage duration should not be reusedYes
CPP_I011Identifier name significanceYes
CPP_I012Static name reuseYes
CPP_I013A tag name shall be a unique identifierYes
CPP_I014A typedef name shall be a unique identifier.Yes
CPP_I015No identifier in one name space should have the same spelling as an identifier in another name space.Yes
CPP_I016Reserved Identifiers or MacrosYes
CPP_I017Shadowed IdentifiersYes
CPP_I018A class or enumeration name shall not be hidden by a variable, function or enumerator declaration in the same scopeYes
CPP_I019The identifier name of a non-member object with static storage duration or static function shall not be reused within a namespaceYes
CPP_I020An identifier name of a function with static storage duration or a non-member object with external or internal linkage should not be reusedYes
CPP_I021Universal character names shall be used only inside character or string literalsYes
CPP_I022Similiar Entity Names within Multiple InheritanceYes
CPP_I023Uppercase 'O' shall not be used as an identifierYes
CPP_I024Lowercase 'l' shall not be used as an identifierYes
CPP_I025The using namespace directive should be used only at the method or function scope.Yes
CPP_L000Calls to COTS library functions that might throw an exception must be enclosed in a try block.Yes
CPP_L001The C library shall not be usedYes
CPP_L002The signal handling facilities of <csignal> shall not be usedYes
CPP_L003The stream input/output library <cstdio> shall not be usedYes
CPP_L004<cstdlib> Library FunctionsYes
CPP_L005Avoid atof, atoi, atol, and atoll from <cstdlib> or <stdlib.h>Yes
CPP_L006Unbounded Functions of <cstring>Yes
CPP_L007Avoid using the library <ctime>Yes
CPP_L008No "errno" allowedYes
CPP_L009No offsetof allowedYes
CPP_L010The setjmp macro and the longjmp function shall not be usedYes
CPP_L011Signal.h should not be usedYes
CPP_L012Standard Library Function NamesYes
CPP_L013Avoid including stdio.hYes
CPP_L014Library stdlib.h - avoid: abort, exit, getenv and systemYes
CPP_L015Guarantee that library functions do not overflowYes
CPP_L016The library <time.h> shall not be usedYes
CPP_L017Inputs from independent components shall be validatedYes
CPP_L018Ensure your random number generator is properly seededYes
CPP_L019Random number engines shall not be default-initializedYes
CPP_L020Do not unlock or destroy another POSIX thread's mutexYes
CPP_L021An iterator shall not be implicitly converted to const_iteratorYes
CPP_L022An argument to std::forward shall not be subsequently usedYes
CPP_L023The std::move shall not be used on objects declared const or const&Yes
CPP_L024Forwarding values to other functions shall be done via: (1) std::move if the value is an rvalue reference, (2) std::forward if the value is forwarding referenceYes
CPP_L025The std::bind shall not be usedYes
CPP_L026Alternate input and output operations on a file stream shall not be used without an intervening flush or positioning callYes
CPP_L027All std::hash specializations for user-defined types shall have a noexcept function call operatorYes
CPP_L028The std::auto_ptr type shall not be usedYes
CPP_L029Library <clocale> (locale.h)Yes
CPP_L030Avoid deadlock with POSIX threads by locking in predefined orderYes
CPP_L031Evaluation of the operand to the typeid operator shall not contain side effects.Yes
CPP_L033Reserved Builtin MacrosYes
CPP_L034Use of the iostream library is preferred over stdio.hYes
CPP_M000Dynamic heap memory allocationYes
CPP_M001The form of the delete expression shall match the form of the new expression used to allocate the memoryYes
CPP_M002Non-placement new or delete expressions shall not be usedYes
CPP_M003Bitwise operations and operations that assume data representation in memory shall not be performed on objects.Yes
CPP_M004Moved-from object shall not be read-accessed.Yes
CPP_M005Uninitialized Memory ReadYes
CPP_M006Functions malloc, calloc, realloc and free shall not be usedYes
CPP_M007When reading strings a maximum field width should be specifiedYes
CPP_M008Dynamically allocated memory shall be set to some value prior to its use as an rvalue or in a testYes
CPP_M009Memory that has been freed shall not be referencedYes
CPP_M010The new[] and delete[] operators shall be used for the allocation and deallocation of memory resourcesYes
CPP_M011The delete[] operator shall be used to deallocate arrays that have been allocated with the new[] operatorYes
CPP_M012The delete[] operator shall be called in the destructor for all member pointers in an object that are pointing to memory that was dynamically allocated by that objectYes
CPP_M013Users shall provide a copy constructor, destructor and assignment operator for a class that uses dynamic memory allocationYes
CPP_M014The operator new should be called with the nothrow option.Yes
CPP_M015When overloading the new[] operator, a corresponding delete[] operator should be provided.Yes
CPP_M016Overloaded new operator should not hide the global new operatorYes
CPP_M017All local allocations made in a method, other than the destructor, should be deallocated prior to exiting the method.Yes
CPP_M018Dynamic Memory Usage on Realtime PhaseYes
CPP_M019No Dynamic Memory AllocationYes
CPP_M020Properly pair allocation and deallocation functionsYes
CPP_M021Declare objects shared between POSIX threads with appropriate storage durationsYes
CPP_N000Naming Convention: ClassesYes
CPP_N001Naming Convention: EnumeratorYes
CPP_N002Naming Convention: EnumsYes
CPP_N003Naming Convention: FilesYes
CPP_N004Naming Convention: FunctionsYes
CPP_N005Naming Convention: MacrosYes
CPP_N006Naming Convention: NamespacesYes
CPP_N007Naming Convention: ParametersYes
CPP_N008Naming Convention: StructsYes
CPP_N009Naming Convention: TypedefsYes
CPP_N010Naming Convention: UnionsYes
CPP_N011Naming Convention: VariablesYes
CPP_N012Only those characters specified in the C++ Language Standard basic source character set shall be used in the source codeYes
CPP_N013Naming Convention: Header File NamesYes
CPP_N014Naming Convention: Implementation File NamesYes
CPP_N015Implementation files, that are defined locally in the project, should have a file name extension of ".cpp"Yes
CPP_N016User defined suffixes of the user defined literal operators shall start with underscore followed by one or more lettersYes
CPP_N017Digit sequences separators ' shall only be used as follows: (1) for decimal, every 3 digits, (2) for hexadecimal, every 2 digits, (3) for binary, every 4 digitsYes
CPP_N018All macros shall be fully capitalizedYes
CPP_N019 Function and variable names shall not be fully capitalizedYes
CPP_P000No more than 2 levels of pointer indirectionYes
CPP_P001Hide Implementation of Pointers Not DereferencedYes
CPP_P002Pointer initialization must use 0, not NULL.Yes
CPP_P003Pointer function parameters must be tested for equality to 0 before accessing the data being pointed toYes
CPP_P004Pointers Must Be InitializedYes
CPP_P005Arguments to a function-like macro shall not contain tokens that look like preprocessing directivesYes
CPP_P006std::make_unique shall be used to construct objects owned by std::unique_ptrYes
CPP_P007A std::unique_ptr shall be used over std::shared_ptr if ownership sharing is not requiredYes
CPP_P008Do Not Use #defineYes
CPP_P009In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##Yes
CPP_P010All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are relatedYes
CPP_P011Ifndef Wrappers or Pragma OnceYes
CPP_P012File Include Matching HeaderYes
CPP_P013Function-like macros shall not be definedYes
CPP_P014_ARestrict Pointer Usage - Multiple DereferencesYes
CPP_P014_BRestrict Pointer Usage - OtherYes
CPP_P015Inactive CodeYes
CPP_P017#include directives in a file shall only be preceded by other preprocessor directives or commentsYes
CPP_P018A macro shall not be defined with the same name as a keywordYes
CPP_P019Macros in BlocksYes
CPP_P020C++ macros shall only be used for include guards, type qualifiers, or storage class specifiersYes
CPP_P021Before dereferencing a pointer, compare it with NULLYes
CPP_P022The pre-processor shall only be used for file inclusion and include guardsYes
CPP_P023Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefinedYes
CPP_P024The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.Yes
CPP_P025All macro identifiers in preprocessor directives shall be defined before use, except in #ifdef and #ifndef preprocessor directives and the defined() operatorNo
CPP_P026avoid #undefYes
CPP_P028A smart pointer shall only be used as a parameter type if it expresses lifetime semanticsYes
CPP_P029A project should not contain unused macro declarationsYes
CPP_P030Invalid Use of std::shared_ptrYes
CPP_P031Invalid Use of std::unique_ptrYes
CPP_P032Cyclic Structure of std::shared_ptrYes
CPP_P033For pointer declarations, the asterisk shall be placed with the variableYes
CPP_P034Const Member Function Returning Non-Const Pointer or ReferenceYes
CPP_P035std::make_shared shall be used to construct objects owned by std::shared_ptrYes
CPP_P036A std::shared_ptr shall be used to represent shared ownershipYes
CPP_P037A std::unique_ptr shall be used to represent exclusive ownershipYes
CPP_P038An already-owned pointer value shall not be stored in an unrelated smart pointerYes
CPP_P039String literals shall not be assigned to non-constant pointersYes
CPP_P040Only nullptr literal shall be used as the null-pointer-constantYes
CPP_P041Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYes
CPP_P042Pointer arithmetic shall not be used with pointers to non-final classesYes
CPP_P043>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same arrayYes
CPP_P044Deleting Pointers to Incomplete Class TypesYes
CPP_P045Array indexing over pointer arithmeticYes
CPP_P046A pointer pointing to an element of an array of objects shall not be passed to a smart pointer of single object typeYes
CPP_P047A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function typeYes
CPP_P048A pointer to member virtual function shall only be tested for equality with null-pointer-constantYes
CPP_P049A pointer operand and any pointer resulting from pointer arithmetic using that operand shall both address elements of the same arrayYes
CPP_P050Literal zero (0) shall not be used as the null-pointer-constant.Yes
CPP_P051Pointer to Integer CastYes
CPP_P052A parameter shall be passed by reference if it can't be NULLYes
CPP_P053A pointer to member shall not access non-existent class membersYes
CPP_P054References should be used instead of pointers when possible.Yes
CPP_P055For pointer declarations, the placement of the * shall be consistentYes
CPP_P056Pointer functions shall return a valid pointer on success and a zero pointer on failureYes
CPP_P057A pointer to dynamic memory that is declared and allocated locally should be declared as an auto_ptr. Yes
CPP_P058Store newed objects in smart pointers in standalone statementsYes
CPP_P059A pointer to a virtual base class shall only be cast to a pointer to a derived class by means of dynamic_castYes
CPP_P060Prefer pass-by-reference-to-const to pass by valueYes
CPP_P061Shared Pointer CaptureYes
CPP_PR000#define and #undef shall not be used on a reserved identifier or reserved macro nameYes
CPP_PR001Include guards shall be providedYes
CPP_PR002Constants defined by #define shall be explicitly declared with uppercase suffixesYes
CPP_PR003Macros shall not be used to change language syntaxYes
CPP_PR004Limit Preprocessor UsageYes
CPP_PR005#include directives should only be preceded by preprocessor directives or commentsYes
CPP_PR006There shall be at most one occurrence of the # or ## operators in a single macro definitionYes
CPP_PR007The defined preprocessor operator shall only be used in one of the two standard formsYes
CPP_PR021The names of standard library macros and objects shall not be reusedYes
CPP_PR030The #pragma directive shall not be usedYes
CPP_PR031#error directive shall not be usedYes
CPP_PR032The # and ## operators should not be usedYes
CPP_PR033The macro offsetof shall not be usedYes
CPP_PR034There shall be no unused include directives (slow)Yes
CPP_PR036Invalid Preprocessor DirectivesYes
CPP_PR037Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined operatorYes
CPP_PR038In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##Yes
CPP_PR039Function-like Macro Containing Preprocessing DirectivesYes
CPP_PR040#include Directives Not Grouped TogetherYes
CPP_PR041Incorrect Use of Pre-processorYes
CPP_S000no unionsYes
CPP_S001Flexible array members shall not be declaredYes
CPP_S002Incorrect Initializer ListsYes
CPP_S003A type defined as struct shall: (1) provide only public data members, (2) not provide any special member functions or methods, (3) not be a base of another struct or class, (4) not inherit from another struct or classYes
CPP_S004Unions Shall not be UsedYes
CPP_SA_DANGLING_POINTERSDangling PointerYesHigh
CPP_SA_DEAD_STORESDead StoresYes
CPP_SA_DIV_ZERODivision by ZeroYesHigh
CPP_SA_LEAKSMemory LeakYesHigh
CPP_SA_NULL_PTRNull Pointer DereferenceYesHigh
CPP_SA_STACK_ADDRESS_ESCAPEStack Address EscapeYesHigh
CPP_SA_UNDEFINED_CALLUndefined CallYesHigh
CPP_SA_UNINITIALIZEDUninitialized ValueYesHigh
CPP_SA_VIRTUAL_CALLSVirtual CallYesHigh
CPP_ST001Not more than one space should precede a ";" with the exception of the null statementYes
CPP_ST002Equal signs should be aligned when they occur in a series of assignment operatorsYes
CPP_ST003Placement of braces for functions shall adhere to one of the following formats and shall be consistentYes
CPP_ST004Code between the beginning and ending braces of a function shall start with one level of indentationYes
CPP_ST005Enum lists should not contain a trailing commaYes
CPP_ST006No line of code should extend beyond column 80Yes
CPP_ST007Declarations shall not be made within an individual block but shall be placed at the function level or at the module level.Yes
CPP_ST008Blank lines should be used to separate distinct algorithmic partsYes
CPP_ST009Parentheses should be used in lengthy logical and arithmetic expressions for clarity.Yes
CPP_ST010Items should be logically groupedYes
CPP_ST011Inline functions should be used instead of macrosYes
CPP_ST012Names that differ in case only or that look similar should not be used.Yes
CPP_ST013Switch statements should be used instead of deeply nested else-ifs when testing a variable for multiple valuesYes
CPP_ST014No line of code should extend beyond 80 charactersYes
CPP_ST015Incrementing and decrementing control variables in loopsYes
CPP_ST016Calls to free should have an if test around them if it is uncertain that the pointer has been properly allocated.Yes
CPP_ST017White space shall not be used in the following placesYes
CPP_ST018Continuation lines shall be indented at least one level from the line being continuedYes
CPP_ST019Statements under case labels shall be indented one levelYes
CPP_ST020For the if-else, while, do, and for control structure, the statement(s) shall be indented one levelYes
CPP_ST021Placement of braces for constructs shall be consistent within a moduleYes
CPP_ST022Boolean expressions involving non-boolean values should always use an explicit test for equality or non-equality.Yes
CPP_ST023At least one blank line shall be placed before commentsYes
CPP_ST024Functions shall have at least one blank line between themYes
CPP_ST025Each area of declarations shall have at least one blank line before and after itYes
CPP_ST026Class naming conventionsYes
CPP_ST027Naming conventions for class data members vs. member function internal dataYes
CPP_ST028Data type naming conventionsYes
CPP_ST029Immutable data naming conventionsYes
CPP_ST030Class design should include the following formatYes
CPP_ST031Separate lines should be used for each member declarationYes
CPP_ST032Indentation shall be at least three spaces, and consistent across modulesYes
CPP_ST033Short FunctionsYes
CPP_T000Typedefs that indicate size and signedness should be used in place of the basic numerical typesYes
CPP_T001Arguments to character-handling functions shall be representable as an unsigned charYes
CPP_T002The std::vector<bool> specialization shall not be usedYes
CPP_T003There should be no unused type declarationsYes
CPP_T004Type long double shall not be usedYes
CPP_T005Type wchar_t shall not be usedYes
CPP_T006The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all declarations and re-declarationsYes
CPP_T007A cvalue expression shall not be implicitly converted to a different underlying typeYes
CPP_T008An implicit integral conversion shall not change the signedness of the underlying typeYes
CPP_T009There shall be no implicit floating-integral conversionsYes
CPP_T010An implicit integral or floating-point conversion shall not reduce the size of the underlying typeYes
CPP_T011There shall be no explicit floating-integral conversions of a cvalue expressionYes
CPP_T012An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expressionYes
CPP_T013An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expressionYes
CPP_T014If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operandYes
CPP_T015The plain char type shall only be used for the storage and use of character valuesYes
CPP_T016Signed char and unsigned char type shall only be used for the storage and use of numeric valuesYes
CPP_T017The first operand of a conditional-operator shall have type boolYes
CPP_T018Bitwise operators shall only be applied to operands of unsigned underlying typeYes
CPP_T019C-style ArrayYes
CPP_T020Casts from a base class to a derived class should not be performed on polymorphic typesYes
CPP_T021A cast shall not remove any const or volatile qualification from the type of a pointer or referenceYes
CPP_T022An object with integer type or pointer to void type shall not be converted to an object with pointer type.Yes
CPP_T023Array to Pointer DecayYes
CPP_T024NULL shall not be used as an integer valueYes
CPP_T025CV-qualifiers shall be placed on the right hand side of the type that is a typedef or a using nameYes
CPP_T026The typedef specifier shall not be usedYes
CPP_T027An expression with enum underlying type shall only have values corresponding to the enumerators of the enumerationYes
CPP_T028Enumeration underlying base type shall be explicitly definedYes
CPP_T029In an enumeration, either (1) none, (2) the first or (3) all enumerators shall be initializedYes
CPP_T030When declaring function templates, the trailing return type syntax shall be used if the return type depends on the type of parameters.Yes
CPP_T031Common ways of passing parameters should be used.Yes
CPP_T032Multiple output values from a function should be returned as a struct or tuple.Yes
CPP_T033"consume" parameters declared as X && shall always be moved from.Yes
CPP_T034"forward" parameters declared as T && shall always be forwarded.Yes
CPP_T035"in" parameters for "cheap to copy" types shall be passed by value.Yes
CPP_T036Output parameters shall not be used.Yes
CPP_T037"in-out" parameters declared as T & shall be modified.Yes
CPP_T038Fixed Width IntegersYes
CPP_T039Non-constant operands to a binary bitwise operator shall have the same underlying typeYes
CPP_T040User defined literals operators shall only perform conversion of passed parametersYes
CPP_T041A binary arithmetic operator and a bitwise operator shall return a "prvalue"Yes
CPP_T042A relational operator shall return a boolean valueYes
CPP_T043If "operator[]" is to be overloaded with a non-const version, const version shall also be implementedYes
CPP_T044Undocumented Use of Floating-point ArithmeticYes
CPP_T045Undocumented Use of Scaled-integer or Fixed-point ArithmeticYes
CPP_T046Assigning Object to an Overlapping ObjectYes
CPP_T047Data types used for interfacingYes
CPP_T048All user-defined conversion operators shall be defined explicitYes
CPP_T049User-defined conversion operators should not be usedYes
CPP_T050Types shall be explicitly specifiedYes
CPP_T051C-style strings shall not be usedYes
CPP_T052String-to-Number Conversion HandlingYes
CPP_T053A type used as a template argument shall provide all members that are used by the templateYes
CPP_T054AAn array or container shall not be accessed beyond its range (Part A)Yes
CPP_T054BAn array or container shall not be accessed beyond its range Part BYes
CPP_T055A value should not be retrieved from a structure or union with a different type than with which it was storedYes
CPP_T056Explicit type casting shall be used when performing calculations with a mix of signed and unsigned values.Yes
CPP_T057Actual arguments shall be explicitly type cast to the appropriate typeYes
CPP_T058Simple integers shall be used to test and set booleansYes
CPP_T059Width-sensitive types should be typedef'd and placed in a header fileYes
CPP_T060Converting a pointer to integer or integer to pointerYes
CPP_T061All Checks/Language Specific/C and C++/Types/Use Const whenever possibleYes
CPP_U000Digraphs shall not be usedYes
CPP_U001Discarded return values.Yes
CPP_U002Inline Functions have more than X LOCYes
CPP_U003Unused Parameters in Non-virtual FunctionsYes
CPP_U004Unused Static GlobalsYes
CPP_U005A project should not contain unused tag declarationsYes
CPP_U006A project shall not contain unused type declarationsYes
CPP_U007Unused LabelsYes
CPP_U008Unnecessary FriendsYes
CPP_U009Special Member FunctionsYes
CPP_U010Unused EntitiesYes
CPP_V000Magic NumbersYes
CPP_V001One Variable per LineYes
CPP_V002Reference Symbols Spacing, (& *)Yes
CPP_V003Declare each variable in a separate declaration statementYes
CPP_V004A project shall not contain non-volatile POD variables having only one use.Yes
CPP_V005Types or externals declared at the function level.Yes
CPP_V006A variable which is not modified shall be const qualifiedYes
CPP_V007Unused Local VariablesYes
CPP_V008Unused Static GlobalYes
CPP_V009Using-directives shall not be used.Yes
CPP_V010Variables should be commentedYes
CPP_V011All variables shall have a defined value before they are usedYes
CPP_V012Explicit VirtualYes
CPP_V013There shall be no more than one definition of each virtual function on each path through the inheritance hierarchyYes
CPP_V014A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYes
CPP_V015There shall be no unused parameters (named or unnamed) in the set of parameters for a virtual function and all the functions that override itYes
CPP_V016Virtual Call in Constructor/DestructorYes
CPP_V017A project shall not contain instances of non-volatile variables being given values that are not subsequently usedYes
CPP_V018Auto VariableYes
CPP_V019Initializing Variables Without Using Braced-InitializationYes
CPP_V020Class members that are not dependent on template class parameters should be defined in a separate base classYes
CPP_V021Variables should not be altered more than once in an expressionYes
CPP_V022Variables shall not be implicitly captured in a lambda expressionYes
CPP_V023Literal values shall not be used apart from type initialization, otherwise symbolic names shall be used insteadYes
CPP_V024Variables of type char shall be explicitly qualified as signed or unsigned when used to store numbersYes
CPP_V025Every variable shall be declared with a specific typeYes
CPP_V026Local variables shall be initialized when declaredYes
CPP_V027Globals in header files shall be ifdef'dYes
CPP_V028Constants should be declared as const values as opposed to #define directives.Yes
CPP_V029The const_cast operator should be used exclusively for altering the constness attribute of a variable.Yes
CPP_V030The dynamic_cast operator should be used exclusively for casting within an inheritance hierarchy.Yes
CPP_V031The static_cast operator should be used for routine cast operations not provided by const_cast and dynamic_cast. Yes
CPP_V032Use of the reinterpret_cast operator should be avoidedYes
CPP_V033Typedef'd variables in a class shall be placed in an include fileYes
CPP_V034STL containers (vector, list, map, etc.) should be used instead of C-style arrays whenever possible.Yes
CPP_V035Objects that do not outlive a function shall have automatic storage durationYes
CPP_V036Static data member initialization should be placed in the class .cpp fileYes
CPP_V037Initializer lists should be used to initialize member variables over direct assignment.Yes
CPP_V038The concept of information hiding should be implemented.Yes
CPP_V039Within an object, most instance variables should be accessed directly. Methods should be used to set variables whose values are determined by an algorithm.Yes
CPP_V042An object shall not be accessed outside of its lifetimeNo
CPP_VF000Every class that contains virtual functions shall provide a virtual destructorYes
CPP_VF001Access levels should not be mixed (public, protected, private) when overriding virtual functions.Yes
CPP_VF002Virtual Call in Constructor/DestructorYes
CPP_WARN_ABSOLUTE_VALUEAbsolute Value Proper UsageYes
CPP_WARN_ABSTRACT_FINAL_CLASSAbstract Classes Should Not Be Final or SealedYes
CPP_WARN_ABSTRACT_VBASE_INITNo Useless Init for Abstract Virtual BaseYes
CPP_WARN_ADDRESS_OF_PACKED_MEMBERDo Not Take the Address of Packed MembersYes
CPP_WARN_ADDRESS_OF_TEMPORARYDo Not Take the Address of Temporary ObjectsYesHigh
CPP_WARN_AIX_COMPATIBM AIX Compatibility with Byte AlignmentYes
CPP_WARN_ALIGN_MISMATCHMatch Byte Alignment of ArgumentsYes
CPP_WARN_ALLOCADo Not Use Certain Allocation FunctionsYes
CPP_WARN_ALLOCA_WITH_ALIGN_ALIGNOFCorrect Usage of Second Argument of Certain Allocation FunctionsYes
CPP_WARN_ALWAYS_INLINE_COROUTINEAlways Inline Coroutine FunctionsYes
CPP_WARN_AMBIGUOUS_DELETEAmbiguous DeleteYes
CPP_WARN_AMBIGUOUS_ELLIPSISAmbiguous EllipsisYes
CPP_WARN_AMBIGUOUS_MACROAmbiguous MacroYes
CPP_WARN_AMBIGUOUS_MEMBER_TEMPLATEAmbiguous Member TemplateYes
CPP_WARN_AMBIGUOUS_REVERSED_OPERATORAmbiguous Reversed OperatorYes
CPP_WARN_ANALYZER_INCOMPATIBLE_PLUGINAnalyzer Incompatible PluginYes
CPP_WARN_ANON_ENUM_ENUM_CONVERSIONAnon-Enum Enum ConversionYes
CPP_WARN_ANONYMOUS_PACK_PARENSAnonymous Pack ParenthesesYes
CPP_WARN_ARC_BRIDGE_CASTS_DISALLOWED_IN_NONARCARC (Automatic Reference Counting) Bridge Casts Disallowed in Non-ARCYes
CPP_WARN_ARC_MAYBE_REPEATED_USE_OF_WEAKARC Maybe Repeated Use of WeakYes
CPP_WARN_ARC_RETAIN_CYCLESARC Retain CyclesYes
CPP_WARN_ARC_UNSAFE_RETAINED_ASSIGNARC Unsafe Retained AssignYes
CPP_WARN_ARGUMENT_OUTSIDE_RANGEArgument Outside RangeYes
CPP_WARN_ARGUMENT_UNDEFINED_BEHAVIOURArgument Undefined BehaviourYes
CPP_WARN_ARRAY_BOUNDSArray BoundsYesHigh
CPP_WARN_ARRAY_BOUNDS_POINTER_ARITHMETICArray Bounds Pointer ArithmeticYes
CPP_WARN_ARRAY_PARAMETERArray ParameterYes
CPP_WARN_ASM_OPERAND_WIDTHSAssembly Operand WidthsYes
CPP_WARN_ASSIGN_ENUMAssign EnumYes
CPP_WARN_ASSUMEDiscarded Side Effects to __assume FunctionYes
CPP_WARN_ATOMIC_ACCESSAtomic AccessYes
CPP_WARN_ATOMIC_ALIGNMENTAtomic AlignmentYes
CPP_WARN_ATOMIC_IMPLICIT_SEQ_CSTAtomic Implicitly Sequentially-ConsistentYes
CPP_WARN_ATOMIC_MEMORY_ORDERINGAtomic Memory OrderingYes
CPP_WARN_AUTO_DISABLE_VPTR_SANITIZERAuto Disable Virtual Pointer SanitizerYes
CPP_WARN_AUTO_STORAGE_CLASSAuto Storage ClassYes
CPP_WARN_AVAILABILITYAvailability AttributeYesHigh
CPP_WARN_AVR_RTLIB_LINKING_QUIRKSAVR RTLIB (Real-Time Library) Linking QuirksYes
CPP_WARN_BACKEND_PLUGINBackend PluginYes
CPP_WARN_BACKSLASH_NEWLINE_ESCAPEBackslash Newline EscapeYesHigh
CPP_WARN_BAD_FUNCTION_CASTDo Not Cast from Function Call of One Type to AnotherYes
CPP_WARN_BIND_TO_TEMPORARY_COPYBind to Temporary CopyYes
CPP_WARN_BINDING_IN_CONDITIONBinding in ConditionYes
CPP_WARN_BIT_INT_EXTENSIONBit Int ExtensionYes
CPP_WARN_BITFIELD_CONSTANT_CONVERSIONBitfield Constant ConversionYesHigh
CPP_WARN_BITFIELD_ENUM_CONVERSIONBitfield Enum ConversionYes
CPP_WARN_BITFIELD_WIDTHDo Not Exceed Bit-Field WidthYesHigh
CPP_WARN_BITWISE_CONDITIONAL_PARENTHESESBitwise Conditional ParenthesesYes
CPP_WARN_BITWISE_INSTEAD_OF_LOGICALBitwise Instead of LogicalYes
CPP_WARN_BITWISE_OP_PARENTHESESBitwise Operator ParenthesesYes
CPP_WARN_BOOL_CONVERSIONBool ConversionYesHigh
CPP_WARN_BOOL_OPERATIONBool OperationYes
CPP_WARN_BRACED_SCALAR_INITBraced Scalar InitYes
CPP_WARN_BRANCH_PROTECTIONBranch ProtectionYes
CPP_WARN_BUILTIN_ASSUME_ALIGNED_ALIGNMENTBuiltin Assume Aligned AlignmentYes
CPP_WARN_BUILTIN_MACRO_REDEFINEDBuiltin Macro RedefinedYesHigh
CPP_WARN_BUILTIN_MEMCPY_CHK_SIZEBuiltin Memcpy Check SizeYesHigh
CPP_WARN_BUILTIN_REQUIRES_HEADERBuiltin Requires HeaderYes
CPP_WARN_C2X_EXTENSIONSC2X ExtensionsYes
CPP_WARN_C11_EXTENSIONSC11 ExtensionsYes
CPP_WARN_C99_COMPATC99 CompatibilityYes
CPP_WARN_C99_DESIGNATORC99 DesignatorYes
CPP_WARN_C99_EXTENSIONSC99 ExtensionsYes
CPP_WARN_CALL_TO_PURE_VIRTUAL_FROM_CTOR_DTORCall to Pure Virtual from Constructor or DestructorYesHigh
CPP_WARN_CALLED_ONCE_PARAMETERCalled once ParameterYes
CPP_WARN_CAST_ALIGNCast AlignYes
CPP_WARN_CAST_CALLING_CONVENTIONCast Calling ConventionYes
CPP_WARN_CAST_FUNCTION_TYPECast Function TypeYes
CPP_WARN_CAST_QUALCast QualifiersYes
CPP_WARN_CAST_QUAL_UNRELATEDCast Qualifiers UnrelatedYesHigh
CPP_WARN_CHAR_SUBSCRIPTSChar SubscriptsYes
CPP_WARN_CLANG_CL_PCHClang-CL Precompiled HeadersYes
CPP_WARN_CLASS_CONVERSIONClass ConversionYesHigh
CPP_WARN_CLASS_VARARGSClass Variadic ArgumentsYes
CPP_WARN_CMSE_UNION_LEAKCMSE (Cortex-M Support for Security Extension) Union LeakYes
CPP_WARN_COMMAComma Operator MisuseYes
CPP_WARN_COMMENTComment MisuseYes
CPP_WARN_COMPARE_DISTINCT_POINTER_TYPESCompare Distinct Pointer TypesYesHigh
CPP_WARN_COMPLEX_COMPONENT_INITComplex Component InitYes
CPP_WARN_COMPOUND_TOKEN_SPLIT_BY_MACROCompound Token Split by MacroYesHigh
CPP_WARN_COMPOUND_TOKEN_SPLIT_BY_SPACECompound Token Split by SpaceYes
CPP_WARN_CONDITIONAL_TYPE_MISMATCHConditional Type MismatchYesHigh
CPP_WARN_CONDITIONAL_UNINITIALIZEDConditional UninitializedYes
CPP_WARN_CONSTANT_CONVERSIONConstant ConversionYesHigh
CPP_WARN_CONSTANT_EVALUATEDConstant EvaluatedYes
CPP_WARN_CONSTANT_LOGICAL_OPERANDConstant Logical OperandYesHigh
CPP_WARN_CONSTEXPR_NOT_CONSTConstexpr Not ConstYes
CPP_WARN_CONSUMEDConsumable AttributeYes
CPP_WARN_CONVERSIONType ConversionYes
CPP_WARN_COROUTINECoroutine Return TypeYes
CPP_WARN_COROUTINE_MISSING_UNHANDLED_EXCEPTIONCoroutine Missing Unhandled ExceptionYes
CPP_WARN_COVERED_SWITCH_DEFAULTCovered Switch DefaultYes
CPP_WARN_CPP_COMPATC++ CompatibilityYes
CPP_WARN_CPP2B_EXTENSIONSC++2B ExtensionsYes
CPP_WARN_CPP11_COMPATC++11 CompatibilityYes
CPP_WARN_CPP11_COMPAT_DEPRECATED_WRITABLE_STRINGSC++11 Compatibility Deprecated Writable StringsYesHigh
CPP_WARN_CPP11_COMPAT_RESERVED_USER_DEFINED_LITERALC++11 Compatibility Reserved User Defined LiteralYes
CPP_WARN_CPP11_EXTENSIONSC++11 ExtensionsYes
CPP_WARN_CPP11_EXTRA_SEMIC++11 Extra SemicolonYes
CPP_WARN_CPP11_INLINE_NAMESPACEC++11 Inline NamespaceYes
CPP_WARN_CPP11_LONG_LONGC++11 Long LongYes
CPP_WARN_CPP11_NARROWINGC++11 NarrowingYes
CPP_WARN_CPP14_ATTRIBUTE_EXTENSIONSC++14 Attribute ExtensionsYes
CPP_WARN_CPP14_BINARY_LITERALC++14 Binary LiteralYes
CPP_WARN_CPP14_EXTENSIONSC++14 ExtensionsYes
CPP_WARN_CPP17_ATTRIBUTE_EXTENSIONSC++17 Attribute ExtensionsYes
CPP_WARN_CPP17_COMPAT_MANGLINGC++17 Compatibility ManglingYes
CPP_WARN_CPP17_EXTENSIONSC++17 ExtensionsYes
CPP_WARN_CPP20_ATTRIBUTE_EXTENSIONSC++20 Attribute ExtensionsYes
CPP_WARN_CPP20_COMPATC++20 CompatibilityYes
CPP_WARN_CPP20_DESIGNATORC++20 DesignatorYes
CPP_WARN_CPP20_EXTENSIONSC++20 ExtensionsYes
CPP_WARN_CPP98_COMPATC++98 CompatibilityYes
CPP_WARN_CPP98_COMPAT_BIND_TO_TEMPORARY_COPYC++98 Compatibility Bind to Temporary CopyYes
CPP_WARN_CPP98_COMPAT_EXTRA_SEMIC++98 Compatibility Extra SemicolonYes
CPP_WARN_CPP98_COMPAT_LOCAL_TYPE_TEMPLATE_ARGSC++98 Compatibility Local Type Template ArgsYes
CPP_WARN_CPP98_COMPAT_PEDANTICC++98 Compatibility PedanticYes
CPP_WARN_CPP98_COMPAT_UNNAMED_TYPE_TEMPLATE_ARGSC++98 Compatibility Unnamed Type Template ArgsYes
CPP_WARN_CPP98_CPP11_COMPAT_BINARY_LITERALC++98 C++11 Compatibility Binary LiteralYes
CPP_WARN_CTAD_MAYBE_UNSUPPORTEDCTAD (Class Template Argument Deduction) Maybe UnsupportedYes
CPP_WARN_CXX_ATTRIBUTE_EXTENSIONC++ Attribute ExtensionYes
CPP_WARN_DANGLINGDangling PointersYesHigh
CPP_WARN_DANGLING_ELSEDangling ElseYes
CPP_WARN_DANGLING_FIELDDangling FieldYesHigh
CPP_WARN_DANGLING_GSLDangling Pointers Found by Guidelines Support LibraryYesHigh
CPP_WARN_DANGLING_INITIALIZER_LISTDangling Initializer ListYesHigh
CPP_WARN_DARWIN_SDK_SETTINGSDarwin SDK SettingsYes
CPP_WARN_DATE_TIMEDate and Time MacrosYes
CPP_WARN_DEALLOC_IN_CATEGORYDealloc in CategoryYes
CPP_WARN_DEBUG_COMPRESSION_UNAVAILABLEDebug Compression UnavailableYes
CPP_WARN_DECLARATION_AFTER_STATEMENTDeclaration After StatementYes
CPP_WARN_DEFAULTED_FUNCTION_DELETEDDefaulted Function DeletedYesHigh
CPP_WARN_DELEGATING_CTOR_CYCLESDelegating Constructor CyclesYesHigh
CPP_WARN_DELETE_ABSTRACT_NON_VIRTUAL_DTORDelete Abstract Non-Virtual DestructorYesHigh
CPP_WARN_DELETE_INCOMPLETEDelete IncompleteYesHigh
CPP_WARN_DELETE_NON_ABSTRACT_NON_VIRTUAL_DTORDelete Non-Abstract Non-Virtual DestructorYes
CPP_WARN_DEPRECATEDDeprecatedYes
CPP_WARN_DEPRECATED_ALTIVEC_SRC_COMPATDeprecated AltiVec Instruction Set Source CompatibilityYes
CPP_WARN_DEPRECATED_ANON_ENUM_ENUM_CONVERSIONDeprecated Anon-Enum, Enum ConversionYes
CPP_WARN_DEPRECATED_ARRAY_COMPAREDeprecated Array CompareYes
CPP_WARN_DEPRECATED_ATTRIBUTESDeprecated AttributesYes
CPP_WARN_DEPRECATED_BUILTINSDeprecated BuiltinsYesHigh
CPP_WARN_DEPRECATED_COMMA_SUBSCRIPTDeprecated Comma SubscriptYes
CPP_WARN_DEPRECATED_COPYDeprecated CopyYes
CPP_WARN_DEPRECATED_COPY_WITH_DTORDeprecated Copy with DestructorYes
CPP_WARN_DEPRECATED_COPY_WITH_USER_PROVIDED_COPYDeprecated Copy with User Provided CopyYes
CPP_WARN_DEPRECATED_COPY_WITH_USER_PROVIDED_DTORDeprecated Copy with User Provided DestructorYes
CPP_WARN_DEPRECATED_COROUTINEDeprecated CoroutineYes
CPP_WARN_DEPRECATED_DECLARATIONSDeprecated DeclarationsYesHigh
CPP_WARN_DEPRECATED_DYNAMIC_EXCEPTION_SPECDeprecated Dynamic Exception SpecYes
CPP_WARN_DEPRECATED_EXPERIMENTAL_COROUTINEDeprecated Experimental CoroutineYes
CPP_WARN_DEPRECATED_IMPLEMENTATIONSDeprecated ImplementationsYes
CPP_WARN_DEPRECATED_INCREMENT_BOOLDeprecated Increment BoolYesHigh
CPP_WARN_DEPRECATED_NON_PROTOTYPEDeprecated Non-PrototypeYesHigh
CPP_WARN_DEPRECATED_REGISTERDeprecated RegisterYesHigh
CPP_WARN_DEPRECATED_STATIC_ANALYZER_FLAGDeprecated Static Analyzer FlagYes
CPP_WARN_DEPRECATED_THIS_CAPTUREDeprecated This CaptureYes
CPP_WARN_DEPRECATED_TYPEDeprecated TypeYes
CPP_WARN_DEPRECATED_VOLATILEDeprecated VolatileYesHigh
CPP_WARN_DISABLED_MACRO_EXPANSIONDisabled Macro ExpansionYes
CPP_WARN_DIVISION_BY_ZERODivision by ZeroYesHigh
CPP_WARN_DLL_ATTRIBUTE_ON_REDECLARATIONDLL Attribute on Re-DeclarationYes
CPP_WARN_DLLEXPORT_EXPLICIT_INSTANTIATION_DECLDLLexport Explicit Instantiation DeclYes
CPP_WARN_DLLIMPORT_STATIC_FIELD_DEFDLLimport Static Field DefYes
CPP_WARN_DOCUMENTATIONDocumentation WarningsYes
CPP_WARN_DOCUMENTATION_DEPRECATED_SYNCDocumentation Deprecated SyncYes
CPP_WARN_DOCUMENTATION_HTMLDocumentation HtmlYes
CPP_WARN_DOCUMENTATION_PEDANTICDocumentation PedanticYes
CPP_WARN_DOCUMENTATION_UNKNOWN_COMMANDDocumentation Unknown CommandYes
CPP_WARN_DOLLAR_IN_IDENTIFIER_EXTENSIONDollar in Identifier ExtensionYes
CPP_WARN_DOUBLE_PROMOTIONDouble PromotionYes
CPP_WARN_DTOR_NAMEDestructor NameYes
CPP_WARN_DTOR_TYPEDEFDestructor TypedefYes
CPP_WARN_DUPLICATE_DECL_SPECIFIERDuplicate Decl SpecifierYes
CPP_WARN_DUPLICATE_ENUMDuplicate EnumYes
CPP_WARN_DUPLICATE_METHOD_ARGDuplicate Method ArgYes
CPP_WARN_DUPLICATE_METHOD_MATCHDuplicate Method MatchYes
CPP_WARN_DUPLICATE_PROTOCOLDuplicate ProtocolYes
CPP_WARN_DYNAMIC_CLASS_MEMACCESSDynamic Class Memory AccessYesHigh
CPP_WARN_DYNAMIC_EXCEPTION_SPECDynamic Exception SpecYes
CPP_WARN_ELABORATED_ENUM_BASEElaborated Enum BaseYes
CPP_WARN_ELABORATED_ENUM_CLASSElaborated Enum ClassYes
CPP_WARN_EMBEDDED_DIRECTIVEEmbedded DirectiveYes
CPP_WARN_EMPTY_BODYControl Loop Shall Not Have Empty BodyYes
CPP_WARN_EMPTY_DECOMPOSITIONDecomposition Group Shall Not Be EmptyYes
CPP_WARN_EMPTY_INIT_STMTNo Empty Initialization StatementsYes
CPP_WARN_EMPTY_TRANSLATION_UNITEmpty Translation UnitYes
CPP_WARN_ENUM_COMPAREEnum CompareYesHigh
CPP_WARN_ENUM_COMPARE_CONDITIONALEnum Compare ConditionalYes
CPP_WARN_ENUM_COMPARE_SWITCHEnum Compare SwitchYesHigh
CPP_WARN_ENUM_CONVERSIONEnum ConversionYes
CPP_WARN_ENUM_ENUM_CONVERSIONEnum Enum ConversionYes
CPP_WARN_ENUM_FLOAT_CONVERSIONEnum Float ConversionYes
CPP_WARN_ENUM_TOO_LARGEEnum Too LargeYes
CPP_WARN_EXCEPTIONSExceptionsYesHigh
CPP_WARN_EXCESS_INITIALIZERSExcess InitializersYes
CPP_WARN_EXIT_TIME_DESTRUCTORSExit Time DestructorsYes
CPP_WARN_EXPANSION_TO_DEFINEDExpansion to DefinedYes
CPP_WARN_EXPORT_UNNAMEDExport UnnamedYes
CPP_WARN_EXPORT_USING_DIRECTIVEExport Using DirectiveYes
CPP_WARN_EXTERN_C_COMPATExtern C CompatibilityYesHigh
CPP_WARN_EXTERN_INITIALIZERExtern InitializerYesHigh
CPP_WARN_EXTRAExtra WarningsYes
CPP_WARN_EXTRA_QUALIFICATIONExtra QualificationYesHigh
CPP_WARN_EXTRA_SEMIExtra SemicolonYes
CPP_WARN_EXTRA_SEMI_STMTExtra Semicolon in Empty Expression StatementYes
CPP_WARN_EXTRA_TOKENSExtra TokensYes
CPP_WARN_FINAL_DTOR_NON_FINAL_CLASSFinal Destructor Non-Final ClassYes
CPP_WARN_FINAL_MACROFinal Macros Should Not Be RedefinedYes
CPP_WARN_FIXED_ENUM_EXTENSIONFixed Enum ExtensionYes
CPP_WARN_FIXED_POINT_OVERFLOWFixed Point OverflowYesHigh
CPP_WARN_FLAG_ENUMFlag EnumYesHigh
CPP_WARN_FLEXIBLE_ARRAY_EXTENSIONSFlexible Array ExtensionsYes
CPP_WARN_FLOAT_CONVERSIONFloat ConversionYes
CPP_WARN_FLOAT_EQUALFloat EqualYes
CPP_WARN_FLOAT_OVERFLOW_CONVERSIONFloat Overflow ConversionYes
CPP_WARN_FLOAT_ZERO_CONVERSIONFloat Zero ConversionYes
CPP_WARN_FOR_LOOP_ANALYSISFor Loop AnalysisYes
CPP_WARN_FORMATFormat StringYesHigh
CPP_WARN_FORMAT_EXTRA_ARGSFormat Extra ArgsYesHigh
CPP_WARN_FORMAT_INSUFFICIENT_ARGSFormat Insufficient ArgsYesHigh
CPP_WARN_FORMAT_INVALID_SPECIFIERFormat Invalid SpecifierYesHigh
CPP_WARN_FORMAT_NON_ISOFormat Non-ISOYes
CPP_WARN_FORMAT_NONLITERALFormat Non-LiteralYes
CPP_WARN_FORMAT_PEDANTICFormat PedanticYes
CPP_WARN_FORMAT_SECURITYFormat SecurityYesHigh
CPP_WARN_FORMAT_TYPE_CONFUSIONFormat Type ConfusionYes
CPP_WARN_FORMAT_ZERO_LENGTHFormat Zero LengthYesHigh
CPP_WARN_FORTIFY_SOURCEFortify SourceYesHigh
CPP_WARN_FOUR_CHAR_CONSTANTSFour Char ConstantsYes
CPP_WARN_FRAME_ADDRESSFrame AddressYes
CPP_WARN_FREE_NONHEAP_OBJECTFree Non-Heap ObjectYesHigh
CPP_WARN_FUNCTION_MULTIVERSIONFunction Multi-VersionYes
CPP_WARN_FUSE_LD_PATHFuse LD PathYes
CPP_WARN_GCC_COMPATGCC CompatibilityYes
CPP_WARN_GLOBAL_CONSTRUCTORSGlobal ConstructorsYes
CPP_WARN_GLOBAL_ISELGlobalISel (Global Instruction Selection) FrameworkYes
CPP_WARN_GNU_ALIGNOF_EXPRESSIONGNU Alignof ExpressionYes
CPP_WARN_GNU_ANONYMOUS_STRUCTGNU Anonymous StructYes
CPP_WARN_GNU_ARRAY_MEMBER_PAREN_INITGNU Array Member Parentheses InitYes
CPP_WARN_GNU_AUTO_TYPEGNU Auto TypeYes
CPP_WARN_GNU_BINARY_LITERALGNU Binary LiteralYes
CPP_WARN_GNU_CASE_RANGEGNU Case RangeYes
CPP_WARN_GNU_COMPLEX_INTEGERGNU Complex IntegerYes
CPP_WARN_GNU_COMPOUND_LITERAL_INITIALIZERGNU Compound Literal InitializerYes
CPP_WARN_GNU_CONDITIONAL_OMITTED_OPERANDGNU Conditional Omitted OperandYes
CPP_WARN_GNU_DESIGNATORGNU DesignatorYes
CPP_WARN_GNU_EMPTY_INITIALIZERGNU Empty InitializerYes
CPP_WARN_GNU_EMPTY_STRUCTGNU Empty StructYes
CPP_WARN_GNU_FLEXIBLE_ARRAY_INITIALIZERGNU Flexible Array InitializerYes
CPP_WARN_GNU_FLEXIBLE_ARRAY_UNION_MEMBERGNU Flexible Array Union MemberYes
CPP_WARN_GNU_FOLDING_CONSTANTGNU Folding ConstantYes
CPP_WARN_GNU_IMAGINARY_CONSTANTGNU Imaginary ConstantYes
CPP_WARN_GNU_INCLUDE_NEXTGNU Include NextYes
CPP_WARN_GNU_INLINE_CPP_WITHOUT_EXTERNGNU Inline Cpp Without ExternYes
CPP_WARN_GNU_LABEL_AS_VALUEGNU Label as ValueYes
CPP_WARN_GNU_LINE_MARKERGNU Line MarkerYes
CPP_WARN_GNU_NULL_POINTER_ARITHMETICGNU Null Pointer ArithmeticYes
CPP_WARN_GNU_POINTER_ARITHGNU Pointer ArithmeticYes
CPP_WARN_GNU_REDECLARED_ENUMGNU Re-Declared EnumYes
CPP_WARN_GNU_STATEMENT_EXPRESSIONGNU Statement ExpressionYes
CPP_WARN_GNU_STATEMENT_EXPRESSION_FROM_MACRO_EXPANSIONGNU Statement Expression from Macro ExpansionYes
CPP_WARN_GNU_STATIC_FLOAT_INITGNU Static Float InitYes
CPP_WARN_GNU_STRING_LITERAL_OPERATOR_TEMPLATEGNU String Literal Operator TemplateYes
CPP_WARN_GNU_UNION_CASTGNU Union CastYes
CPP_WARN_GNU_VARIABLE_SIZED_TYPE_NOT_AT_ENDGNU Variable Sized Type Not at EndYes
CPP_WARN_GNU_ZERO_LINE_DIRECTIVEGNU Zero Line DirectiveYes
CPP_WARN_GNU_ZERO_VARIADIC_MACRO_ARGUMENTSGNU Zero Variadic Macro ArgumentsYes
CPP_WARN_HEADER_GUARDHeader GuardYesHigh
CPP_WARN_HEADER_HYGIENEHeader HygieneYes
CPP_WARN_IDIOMATIC_PARENTHESESIdiomatic ParenthesesYes
CPP_WARN_IGNORED_ATTRIBUTESIgnored AttributesYesHigh
CPP_WARN_IGNORED_AVAILABILITY_WITHOUT_SDK_SETTINGSIgnored Availability Without Sdk SettingsYes
CPP_WARN_IGNORED_OPTIMIZATION_ARGUMENTIgnored Optimization ArgumentYes
CPP_WARN_IGNORED_PRAGMA_INTRINSICIgnored Pragma IntrinsicYes
CPP_WARN_IGNORED_PRAGMASIgnored PragmasYes
CPP_WARN_IGNORED_REFERENCE_QUALIFIERSIgnored Reference QualifiersYesHigh
CPP_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSIONImplicit Const Int Float ConversionYesHigh
CPP_WARN_IMPLICIT_CONVERSION_FLOATING_POINT_TO_BOOLImplicit Conversion Floating Point to BoolYesHigh
CPP_WARN_IMPLICIT_EXCEPTION_SPEC_MISMATCHImplicit Exception Spec MismatchYesHigh
CPP_WARN_IMPLICIT_FALLTHROUGHImplicit FallthroughYes
CPP_WARN_IMPLICIT_FALLTHROUGH_PER_FUNCTIONImplicit Fallthrough Per FunctionYes
CPP_WARN_IMPLICIT_FIXED_POINT_CONVERSIONImplicit Fixed Point ConversionYesHigh
CPP_WARN_IMPLICIT_FLOAT_CONVERSIONImplicit Float ConversionYes
CPP_WARN_IMPLICIT_FUNCTION_DECLARATIONImplicit Function DeclarationYes
CPP_WARN_IMPLICIT_INTImplicit IntYes
CPP_WARN_IMPLICIT_INT_CONVERSIONImplicit Int ConversionYes
CPP_WARN_IMPLICIT_INT_FLOAT_CONVERSIONImplicit Int Float ConversionYes
CPP_WARN_IMPLICIT_RETAIN_SELFImplicit Retain SelfYes
CPP_WARN_IMPLICITLY_UNSIGNED_LITERALImplicitly Unsigned LiteralYesHigh
CPP_WARN_IMPORT_PREPROCESSOR_DIRECTIVE_PEDANTICImport Preprocessor Directive PedanticYes
CPP_WARN_INACCESSIBLE_BASEInaccessible BaseYesHigh
CPP_WARN_INCLUDE_NEXT_ABSOLUTE_PATHInclude Next Absolute PathYes
CPP_WARN_INCLUDE_NEXT_OUTSIDE_HEADERInclude Next Outside HeaderYes
CPP_WARN_INCOMPATIBLE_EXCEPTION_SPECIncompatible Exception SpecYesHigh
CPP_WARN_INCOMPATIBLE_FUNCTION_POINTER_TYPESIncompatible Function Pointer TypesYes
CPP_WARN_INCOMPATIBLE_LIBRARY_REDECLARATIONIncompatible Library RedeclarationYesHigh
CPP_WARN_INCOMPATIBLE_MS_STRUCTIncompatible Microsoft StructYes
CPP_WARN_INCOMPATIBLE_POINTER_TYPESIncompatible Pointer TypesYesHigh
CPP_WARN_INCOMPATIBLE_POINTER_TYPES_DISCARDS_QUALIFIERSIncompatible Pointer Types Discards QualifiersYesHigh
CPP_WARN_INCOMPATIBLE_SYSROOTIncompatible SysrootYes
CPP_WARN_INCOMPLETE_IMPLEMENTATIONIncomplete ImplementationYes
CPP_WARN_INCOMPLETE_SETJMP_DECLARATIONIncomplete Setjmp DeclarationYes
CPP_WARN_INCONSISTENT_DLLIMPORTInconsistent DLLimportYes
CPP_WARN_INCONSISTENT_MISSING_DESTRUCTOR_OVERRIDEInconsistent Missing Destructor OverrideYes
CPP_WARN_INCONSISTENT_MISSING_OVERRIDEInconsistent Missing OverrideYesHigh
CPP_WARN_INCREMENT_BOOLIncrement BoolYesHigh
CPP_WARN_INFINITE_RECURSIONInfinite RecursionYes
CPP_WARN_INITIALIZER_OVERRIDESInitializer OverridesYes
CPP_WARN_INJECTED_CLASS_NAMEInjected Class NameYesHigh
CPP_WARN_INLINE_ASMInline AssemblyYes
CPP_WARN_INLINE_NAMESPACE_REOPENED_NONINLINEInline Namespace Reopened Non-InlineYesHigh
CPP_WARN_INLINE_NEW_DELETEInline New DeleteYes
CPP_WARN_INSTANTIATION_AFTER_SPECIALIZATIONInstantiation After SpecializationYesHigh
CPP_WARN_INT_CONVERSIONInt ConversionYes
CPP_WARN_INT_IN_BOOL_CONTEXTInt in Bool ContextYes
CPP_WARN_INT_TO_POINTER_CASTInt to Pointer CastYesHigh
CPP_WARN_INT_TO_VOID_POINTER_CASTInt to Void Pointer CastYesHigh
CPP_WARN_INTEGER_OVERFLOWInteger OverflowYesHigh
CPP_WARN_INTERRUPT_SERVICE_ROUTINEInterrupt Service RoutineYes
CPP_WARN_INVALID_COMMAND_LINE_ARGUMENTInvalid Command Line ArgumentYes
CPP_WARN_INVALID_CONSTEXPRInvalid ConstexprYes
CPP_WARN_INVALID_IBOUTLETInvalid IBOutletCollection (Interface Builder Outlet Collection)Yes
CPP_WARN_INVALID_INITIALIZER_FROM_SYSTEM_HEADERInvalid Initializer from System HeaderYes
CPP_WARN_INVALID_IOS_DEPLOYMENT_TARGETInvalid iOS Deployment TargetYes
CPP_WARN_INVALID_NO_BUILTIN_NAMESInvalid No Builtin NamesYesHigh
CPP_WARN_INVALID_NORETURNInvalid Noreturn AttributeYesHigh
CPP_WARN_INVALID_OFFSETOFInvalid OffsetofYesHigh
CPP_WARN_INVALID_OR_NONEXISTENT_DIRECTORYInvalid or Nonexistent DirectoryYes
CPP_WARN_INVALID_PARTIAL_SPECIALIZATIONInvalid Partial SpecializationYes
CPP_WARN_INVALID_PP_TOKENInvalid Preprocessor TokenYesHigh
CPP_WARN_INVALID_SOURCE_ENCODINGInvalid Source EncodingYes
CPP_WARN_INVALID_TOKEN_PASTEInvalid Token PasteYes
CPP_WARN_INVALID_UTF8Invalid UTF-8Yes
CPP_WARN_JUMP_SEH_FINALLYJump SEH (Structured Exception Handling) FinallyYes
CPP_WARN_KEYWORD_COMPATKeyword CompatibilityYes
CPP_WARN_KEYWORD_MACROKeyword MacroYes
CPP_WARN_KNR_PROMOTED_PARAMETERK&R Promoted ParameterYes
CPP_WARN_LANGUAGE_EXTENSION_TOKENLanguage Extension TokenYes
CPP_WARN_LARGE_BY_VALUE_COPYLarge by Value CopyYesHigh
CPP_WARN_LINKER_WARNINGSLinker WarningsYes
CPP_WARN_LITERAL_CONVERSIONLiteral ConversionYesHigh
CPP_WARN_LITERAL_RANGELiteral RangeYesHigh
CPP_WARN_LOCAL_TYPE_TEMPLATE_ARGSLocal Type Template ArgsYes
CPP_WARN_LOGICAL_NOT_PARENTHESESLogical Not ParenthesesYesHigh
CPP_WARN_LOGICAL_OP_PARENTHESESLogical Operator ParenthesesYes
CPP_WARN_LONG_LONGLong LongYes
CPP_WARN_MACRO_REDEFINEDMacro RedefinedYesHigh
CPP_WARN_MAINMain Function ConventionsYes
CPP_WARN_MAIN_RETURN_TYPEMain Return TypeYesHigh
CPP_WARN_MALFORMED_WARNING_CHECKMalformed Warning CheckYes
CPP_WARN_MANY_BRACES_AROUND_SCALAR_INITMany Braces Around Scalar InitYesHigh
CPP_WARN_MAX_TOKENSMax TokensYes
CPP_WARN_MAX_UNSIGNED_ZEROMax Unsigned ZeroYesHigh
CPP_WARN_MEMSET_TRANSPOSED_ARGSMemset Transposed ArgsYesHigh
CPP_WARN_MEMSIZE_COMPARISONMemsize ComparisonYesHigh
CPP_WARN_MICROSOFT_ABSTRACTMicrosoft AbstractYes
CPP_WARN_MICROSOFT_ANON_TAGMicrosoft Anonymous TagYes
CPP_WARN_MICROSOFT_CASTMicrosoft CastYes
CPP_WARN_MICROSOFT_CHARIZEMicrosoft Charizing OperatorYes
CPP_WARN_MICROSOFT_COMMENT_PASTEMicrosoft Comment PasteYes
CPP_WARN_MICROSOFT_CONST_INITMicrosoft Const InitYes
CPP_WARN_MICROSOFT_CPP_MACROMicrosoft C++ MacroYes
CPP_WARN_MICROSOFT_DEFAULT_ARG_REDEFINITIONMicrosoft Default Arg RedefinitionYes
CPP_WARN_MICROSOFT_DRECTVE_SECTIONMicrosoft Drectve SectionYes
CPP_WARN_MICROSOFT_END_OF_FILEMicrosoft End of FileYes
CPP_WARN_MICROSOFT_ENUM_FORWARD_REFERENCEMicrosoft Enum Forward ReferenceYes
CPP_WARN_MICROSOFT_ENUM_VALUEMicrosoft Enum ValueYes
CPP_WARN_MICROSOFT_EXCEPTION_SPECMicrosoft Exception SpecYes
CPP_WARN_MICROSOFT_EXISTSMicrosoft ExistsYes
CPP_WARN_MICROSOFT_EXPLICIT_CONSTRUCTOR_CALLMicrosoft Explicit Constructor CallYes
CPP_WARN_MICROSOFT_EXTRA_QUALIFICATIONMicrosoft Extra QualificationYes
CPP_WARN_MICROSOFT_FIXED_ENUMMicrosoft Fixed EnumYes
CPP_WARN_MICROSOFT_FLEXIBLE_ARRAYMicrosoft Flexible ArrayYes
CPP_WARN_MICROSOFT_GOTOMicrosoft GotoYes
CPP_WARN_MICROSOFT_INACCESSIBLE_BASEMicrosoft Inaccessible BaseYes
CPP_WARN_MICROSOFT_INCLUDEMicrosoft IncludeYes
CPP_WARN_MICROSOFT_MUTABLE_REFERENCEMicrosoft Mutable ReferenceYes
CPP_WARN_MICROSOFT_PURE_DEFINITIONMicrosoft Pure DefinitionYes
CPP_WARN_MICROSOFT_REDECLARE_STATICMicrosoft Redeclare StaticYes
CPP_WARN_MICROSOFT_SEALEDMicrosoft SealedYes
CPP_WARN_MICROSOFT_STATIC_ASSERTMicrosoft Static AssertYes
CPP_WARN_MICROSOFT_TEMPLATEMicrosoft TemplateYes
CPP_WARN_MICROSOFT_TEMPLATE_SHADOWMicrosoft Template ShadowYes
CPP_WARN_MICROSOFT_UNION_MEMBER_REFERENCEMicrosoft Union Member ReferenceYes
CPP_WARN_MICROSOFT_UNQUALIFIED_FRIENDMicrosoft Unqualified FriendYes
CPP_WARN_MICROSOFT_USING_DECLMicrosoft Using DeclYes
CPP_WARN_MICROSOFT_VOID_PSEUDO_DTORMicrosoft Void Pseudo DestructorYes
CPP_WARN_MISEXPECTMisuse of __builtin_expect()Yes
CPP_WARN_MISLEADING_INDENTATIONMisleading IndentationYes
CPP_WARN_MISMATCHED_NEW_DELETEMismatched New DeleteYesHigh
CPP_WARN_MISMATCHED_TAGSMismatched TagsYes
CPP_WARN_MISSING_BRACESMissing BracesYes
CPP_WARN_MISSING_CONSTINITMissing ConstinitYes
CPP_WARN_MISSING_DECLARATIONSMissing DeclarationsYesHigh
CPP_WARN_MISSING_EXCEPTION_SPECMissing Exception SpecYesHigh
CPP_WARN_MISSING_FIELD_INITIALIZERSMissing Field InitializersYes
CPP_WARN_MISSING_METHOD_RETURN_TYPEMissing Method Return TypeYes
CPP_WARN_MISSING_NORETURNMissing Noreturn AttributeYes
CPP_WARN_MISSING_PROTOTYPE_FOR_CCMissing Prototype for Calling ConventionYes
CPP_WARN_MISSING_PROTOTYPESMissing PrototypesYes
CPP_WARN_MISSING_SELECTOR_NAMEMissing Selector NameYes
CPP_WARN_MISSING_SYSROOTMissing SysrootYes
CPP_WARN_MISSING_VARIABLE_DECLARATIONSMissing Variable DeclarationsYes
CPP_WARN_MISSPELLED_ASSUMPTIONMisspelled AssumptionYes
CPP_WARN_MODULE_CONFLICTModule ConflictYes
CPP_WARN_MODULE_FILE_CONFIG_MISMATCHModule File Config MismatchYes
CPP_WARN_MODULE_FILE_EXTENSIONModule File ExtensionYes
CPP_WARN_MODULE_IMPORT_IN_EXTERN_CModule Import in Extern CYes
CPP_WARN_MODULES_AMBIGUOUS_INTERNAL_LINKAGEModules Ambiguous Internal LinkageYes
CPP_WARN_MODULES_IMPORT_NESTED_REDUNDANTModules Import Nested RedundantYes
CPP_WARN_MSVC_NOT_FOUNDMSVC Not FoundYes
CPP_WARN_MULTICHARMultiple Characters in Character LiteralYesHigh
CPP_WARN_MULTIPLE_MOVE_VBASEMultiple Move Virtual BaseYesHigh
CPP_WARN_NESTED_ANON_TYPESNested Anon-TypesYes
CPP_WARN_NEW_RETURNS_NULLNew Returns NullYesHigh
CPP_WARN_NEWLINE_EOFNewline EOF (End of File)Yes
CPP_WARN_NODEREFNoderef AttirbuteYesHigh
CPP_WARN_NON_C_TYPEDEF_FOR_LINKAGENon-C Typedef for LinkageYesHigh
CPP_WARN_NON_LITERAL_NULL_CONVERSIONNon-Literal Null ConversionYesHigh
CPP_WARN_NON_POD_VARARGSNon-POD (Plain Old Data) Variadic ArgumentsYesHigh
CPP_WARN_NON_POWER_OF_TWO_ALIGNMENTNon-Power of Two AlignmentYesHigh
CPP_WARN_NON_VIRTUAL_DTORNon-Virtual DestructorYes
CPP_WARN_NONNULLNull as an ArgumentYesHigh
CPP_WARN_NONPORTABLE_INCLUDE_PATHNon-Portable Include PathYesHigh
CPP_WARN_NONPORTABLE_SYSTEM_INCLUDE_PATHNon-Portable System Include PathYes
CPP_WARN_NONPORTABLE_VECTOR_INITIALIZATIONNon-Portable Vector InitializationYes
CPP_WARN_NONTRIVIAL_MEMACCESSNontrivial Memory AccessYesHigh
CPP_WARN_NULL_ARITHMETICNull ArithmeticYesHigh
CPP_WARN_NULL_CHARACTERNull CharacterYesHigh
CPP_WARN_NULL_CONVERSIONNull ConversionYesHigh
CPP_WARN_NULL_DEREFERENCENull DereferenceYesHigh
CPP_WARN_NULL_POINTER_ARITHMETICNull Pointer ArithmeticYes
CPP_WARN_NULL_POINTER_SUBTRACTIONNull Pointer SubtractionYes
CPP_WARN_OBJC_BOOL_CONSTANT_CONVERSIONObjective-C Bool Constant ConversionYes
CPP_WARN_OBJC_CIRCULAR_CONTAINERObjective-C Circular ContainerYes
CPP_WARN_OBJC_MULTIPLE_METHOD_NAMESObjective-C Multiple Method NamesYes
CPP_WARN_OBJC_READONLY_WITH_SETTER_PROPERTYObjective-C Readonly with Setter PropertyYes
CPP_WARN_OBJC_SIGNED_CHAR_BOOL_IMPLICIT_FLOAT_CONVERSIONObjective-C Signed Char Bool Implicit Float ConversionYes
CPP_WARN_OBJC_SIGNED_CHAR_BOOL_IMPLICIT_INT_CONVERSIONObjective-C Signed Char Bool Implicit Int ConversionYes
CPP_WARN_ODROne Definition RuleYesHigh
CPP_WARN_OLD_STYLE_CASTOld Style CastYes
CPP_WARN_OPENMP_51_EXTENSIONSOpenMP 51 ExtensionsYes
CPP_WARN_OPENMP_CLAUSESOpenMP ClausesYes
CPP_WARN_OPENMP_LOOP_FORMOpenMP Loop FormYes
CPP_WARN_OPENMP_MAPPINGOpenMP MappingYes
CPP_WARN_OPENMP_TARGETOpenMP TargetYes
CPP_WARN_OPTION_IGNOREDOption IgnoredYes
CPP_WARN_ORDERED_COMPARE_FUNCTION_POINTERSOrdered Compare Function PointersYesHigh
CPP_WARN_OUT_OF_LINE_DECLARATIONOut of Line DeclarationYes
CPP_WARN_OUT_OF_SCOPE_FUNCTIONOut of Scope FunctionYesHigh
CPP_WARN_OVER_ALIGNEDOver AlignedYes
CPP_WARN_OVERLENGTH_STRINGSLong String LiteralsYes
CPP_WARN_OVERLOADED_SHIFT_OP_PARENTHESESOverloaded Shift Operator ParenthesesYesHigh
CPP_WARN_OVERLOADED_VIRTUALOverloaded VirtualYes
CPP_WARN_OVERRIDE_MODULEOverride ModuleYes
CPP_WARN_OVERRIDING_T_OPTIONOverriding Slash T OptionYes
CPP_WARN_PACKEDPacked AttributeYes
CPP_WARN_PADDEDImplicit PaddingYes
CPP_WARN_PARENTHESESParenthesesYes
CPP_WARN_PARENTHESES_EQUALITYParentheses EqualityYesHigh
CPP_WARN_PASS_FAILEDPass FailedYes
CPP_WARN_PCH_DATE_TIMEPCH (Precompiled Header) Date TimeYes
CPP_WARN_PEDANTICPedanticYes
CPP_WARN_PEDANTIC_CORE_FEATURESPedantic Core FeaturesYes
CPP_WARN_PESSIMIZING_MOVEPessimizing MoveYes
CPP_WARN_POINTER_ARITHPointer ArithmeticYesHigh
CPP_WARN_POINTER_BOOL_CONVERSIONPointer Bool ConversionYesHigh
CPP_WARN_POINTER_COMPAREPointer CompareYesHigh
CPP_WARN_POINTER_INTEGER_COMPAREPointer Integer CompareYesHigh
CPP_WARN_POINTER_SIGNPointer SignYesHigh
CPP_WARN_POINTER_TO_ENUM_CASTPointer to Enum CastYesHigh
CPP_WARN_POINTER_TO_INT_CASTPointer to Int CastYesHigh
CPP_WARN_POINTER_TYPE_MISMATCHPointer Type MismatchYesHigh
CPP_WARN_POISON_SYSTEM_DIRECTORIESPoison System DirectoriesYes
CPP_WARN_POTENTIALLY_EVALUATED_EXPRESSIONPotentially Evaluated ExpressionYesHigh
CPP_WARN_PRAGMA_CLANG_ATTRIBUTEPragma Clang AttributeYes
CPP_WARN_PRAGMA_MESSAGESPreprocessor #Pragma MessagesYes
CPP_WARN_PRAGMA_ONCE_OUTSIDE_HEADERPragma once Outside HeaderYesHigh
CPP_WARN_PRAGMA_PACKPragma PackYes
CPP_WARN_PRAGMA_PACK_SUSPICIOUS_INCLUDEPragma Pack Suspicious IncludeYes
CPP_WARN_PRAGMA_SYSTEM_HEADER_OUTSIDE_HEADERPragma System Header Outside HeaderYes
CPP_WARN_PRAGMASPragmasYes
CPP_WARN_PRE_C2X_COMPATPre C2X CompatibilityYes
CPP_WARN_PRE_CPP2B_COMPATPre C++2B CompatibilityYes
CPP_WARN_PRE_CPP14_COMPATPre C++14 CompatibilityYes
CPP_WARN_PRE_CPP17_COMPATPre C++17 CompatibilityYes
CPP_WARN_PRE_CPP17_COMPAT_PEDANTICPre C++17 Compatibility PedanticYes
CPP_WARN_PRE_CPP20_COMPATPre C++20 CompatibilityYes
CPP_WARN_PRE_CPP20_COMPAT_PEDANTICPre C++20 Compatibility PedanticYes
CPP_WARN_PRE_OPENMP_51_COMPATPre OpenMP 51 CompatibilityYes
CPP_WARN_PREDEFINED_IDENTIFIER_OUTSIDE_FUNCTIONPredefined Identifier Outside FunctionYes
CPP_WARN_PRIVATE_EXTERNPrivate ExternYes
CPP_WARN_PRIVATE_HEADERPrivate HeaderYes
CPP_WARN_PROFILE_INSTR_MISSINGProfile Instrumented Code MissingYes
CPP_WARN_PROFILE_INSTR_OUT_OF_DATEProfile Instrumented Code Out of DateYes
CPP_WARN_PROFILE_INSTR_UNPROFILEDProfile Instrumented Code UnprofiledYes
CPP_WARN_PSABIPSABI (Processor-Specific Application Binary Interface)Yes
CPP_WARN_QUALIFIED_VOID_RETURN_TYPEQualified Void Return TypeYesHigh
CPP_WARN_RANGE_LOOP_BIND_REFERENCERange Loop Bind ReferenceYes
CPP_WARN_RANGE_LOOP_CONSTRUCTRange Loop ConstructYes
CPP_WARN_REDECLARED_CLASS_MEMBERRe-Declared Class MemberYesHigh
CPP_WARN_REDUNDANT_CONSTEVAL_IFRedundant Consteval IfYesHigh
CPP_WARN_REDUNDANT_MOVERedundant MoveYes
CPP_WARN_REDUNDANT_PARENSRedundant ParenthesesYes
CPP_WARN_REGISTERRegister KeywordYes
CPP_WARN_REINTERPRET_BASE_CLASSReinterpret Base ClassYesHigh
CPP_WARN_REORDER_CTORReorder ConstructorYes
CPP_WARN_REORDER_INIT_LISTReorder Initializer ListYesHigh
CPP_WARN_RESERVED_IDENTIFIERReserved IdentifierYes
CPP_WARN_RESERVED_MACRO_IDENTIFIERReserved Macro IdentifierYes
CPP_WARN_RESERVED_USER_DEFINED_LITERALReserved User Defined LiteralYes
CPP_WARN_RESTRICT_EXPANSIONRestrict ExpansionYes
CPP_WARN_RETAINED_LANGUAGE_LINKAGERetained Language LinkageYes
CPP_WARN_RETURN_STACK_ADDRESSReturn Stack AddressYesHigh
CPP_WARN_RETURN_TYPEReturn TypeYesHigh
CPP_WARN_RETURN_TYPE_C_LINKAGEReturn Type C LinkageYesHigh
CPP_WARN_REWRITE_NOT_BOOLRewrite Not BoolYes
CPP_WARN_RTTIRun-Time Type InformationYes
CPP_WARN_SARIF_FORMAT_UNSTABLESARIF Format UnstableYes
CPP_WARN_SECTIONSection AttributesYes
CPP_WARN_SELF_ASSIGNSelf AssignYes
CPP_WARN_SELF_ASSIGN_FIELDSelf Assign FieldYesHigh
CPP_WARN_SELF_ASSIGN_OVERLOADEDSelf Assign OverloadedYes
CPP_WARN_SELF_MOVESelf MoveYes
CPP_WARN_SENTINELSentinel AttributeYes
CPP_WARN_SERIALIZED_DIAGNOSTICSSerialized DiagnosticsYes
CPP_WARN_SHADOWShadowing IdentifiersYes
CPP_WARN_SHADOW_FIELDShadowing FieldYes
CPP_WARN_SHADOW_FIELD_IN_CONSTRUCTORShadowing Field in ConstructorYes
CPP_WARN_SHADOW_FIELD_IN_CONSTRUCTOR_MODIFIEDShadowing Field in Constructor ModifiedYes
CPP_WARN_SHADOW_UNCAPTURED_LOCALShadowing Uncaptured LocalYes
CPP_WARN_SHIFT_COUNT_NEGATIVEShift Count NegativeYesHigh
CPP_WARN_SHIFT_COUNT_OVERFLOWShift Count OverflowYesHigh
CPP_WARN_SHIFT_NEGATIVE_VALUEShift Negative ValueYesHigh
CPP_WARN_SHIFT_OP_PARENTHESESShift Operator ParenthesesYesHigh
CPP_WARN_SHIFT_OVERFLOWShift OverflowYesHigh
CPP_WARN_SHIFT_SIGN_OVERFLOWShift Sign OverflowYes
CPP_WARN_SHORTEN_64_TO_32Shorten Integer Type WidthYes
CPP_WARN_SIGN_COMPARESign CompareYes
CPP_WARN_SIGN_CONVERSIONSign ConversionYes
CPP_WARN_SIGNED_ENUM_BITFIELDSigned Enum BitfieldYes
CPP_WARN_SIGNED_UNSIGNED_WCHARSigned Unsigned WcharYes
CPP_WARN_SINGLE_BIT_BITFIELD_CONSTANT_CONVERSIONSingle Bit Bitfield Constant ConversionYesHigh
CPP_WARN_SIZEOF_ARRAY_ARGUMENTSizeof Array ArgumentYesHigh
CPP_WARN_SIZEOF_ARRAY_DECAYSizeof Array DecayYesHigh
CPP_WARN_SIZEOF_ARRAY_DIVSizeof Array DivisionYesHigh
CPP_WARN_SIZEOF_POINTER_DIVSizeof Pointer DivisionYesHigh
CPP_WARN_SIZEOF_POINTER_MEMACCESSSizeof Pointer Memory AccessYesHigh
CPP_WARN_SLASH_U_FILENAMESlash U FilenameYes
CPP_WARN_SLH_ASM_GOTOSLH (Speculative Load Hardening) Assembly GotoYes
CPP_WARN_SOMETIMES_UNINITIALIZEDSometimes UninitializedYes
CPP_WARN_SOURCE_USES_OPENMPSource Uses OpenMPYes
CPP_WARN_SPIR_COMPATSPIR (Sampler Initializer) CompatibilityYes
CPP_WARN_STACK_EXHAUSTEDStack ExhaustedYes
CPP_WARN_STACK_PROTECTORStack ProtectorYes
CPP_WARN_STATIC_FLOAT_INITStatic Float InitYes
CPP_WARN_STATIC_IN_INLINEStatic in InlineYes
CPP_WARN_STATIC_INLINE_EXPLICIT_INSTANTIATIONStatic Inline Explicit InstantiationYesHigh
CPP_WARN_STATIC_LOCAL_IN_INLINEStatic Local in InlineYesHigh
CPP_WARN_STATIC_SELF_INITStatic Self InitYesHigh
CPP_WARN_STDLIBCXX_NOT_FOUNDLibStdC++ Headers Not FoundYes
CPP_WARN_STRICT_POTENTIALLY_DIRECT_SELECTORStrict Potentially Direct SelectorYes
CPP_WARN_STRICT_PROTOTYPESStrict PrototypesYes
CPP_WARN_STRICT_SELECTOR_MATCHStrict Selector MatchYes
CPP_WARN_STRING_COMPAREString CompareYesHigh
CPP_WARN_STRING_CONCATENATIONString ConcatenationYes
CPP_WARN_STRING_CONVERSIONString ConversionYes
CPP_WARN_STRING_PLUS_CHARString Plus CharYesHigh
CPP_WARN_STRING_PLUS_INTString Plus IntYesHigh
CPP_WARN_STRLCPY_STRLCAT_SIZEStrlcpy Strlcat SizeYesHigh
CPP_WARN_STRNCAT_SIZEStrncat SizeYesHigh
CPP_WARN_SUGGEST_DESTRUCTOR_OVERRIDESuggest Destructor OverrideYes
CPP_WARN_SUGGEST_OVERRIDESuggest OverrideYes
CPP_WARN_SUPER_CLASS_METHOD_MISMATCHSuper Class Method MismatchYes
CPP_WARN_SUSPICIOUS_BZEROSuspicious Argument for Bzero FunctionYes
CPP_WARN_SWITCHSwitch StatementsYesHigh
CPP_WARN_SWITCH_BOOLSwitch BoolYesHigh
CPP_WARN_SWITCH_ENUMSwitch EnumYes
CPP_WARN_SYNC_FETCH_AND_NAND_SEMANTICS_CHANGEDSync Fetch And Nand Semantics ChangedYes
CPP_WARN_TARGET_CLONES_MIXED_SPECIFIERSTarget Clones Mixed SpecifiersYes
CPP_WARN_TAUTOLOGICAL_BITWISE_COMPARETautological Bitwise CompareYes
CPP_WARN_TAUTOLOGICAL_COMPARETautological CompareYes
CPP_WARN_TAUTOLOGICAL_CONSTANT_COMPARETautological Constant CompareYesHigh
CPP_WARN_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARETautological Constant Out of Range CompareYesHigh
CPP_WARN_TAUTOLOGICAL_OVERLAP_COMPARETautological Overlap CompareYes
CPP_WARN_TAUTOLOGICAL_POINTER_COMPARETautological Pointer CompareYesHigh
CPP_WARN_TAUTOLOGICAL_TYPE_LIMIT_COMPARETautological Type Limit CompareYes
CPP_WARN_TAUTOLOGICAL_UNDEFINED_COMPARETautological Undefined CompareYesHigh
CPP_WARN_TAUTOLOGICAL_UNSIGNED_CHAR_ZERO_COMPARETautological Unsigned Char Zero CompareYes
CPP_WARN_TAUTOLOGICAL_UNSIGNED_ENUM_ZERO_COMPARETautological Unsigned Enum Zero CompareYes
CPP_WARN_TAUTOLOGICAL_UNSIGNED_ZERO_COMPARETautological Unsigned Zero CompareYes
CPP_WARN_TAUTOLOGICAL_VALUE_RANGE_COMPARETautological Value Range CompareYes
CPP_WARN_TCB_ENFORCEMENTTCB (Trusted Computing Base) EnforcementYes
CPP_WARN_TENTATIVE_DEFINITION_INCOMPLETE_TYPETentative Definition Incomplete TypeYesHigh
CPP_WARN_THREAD_SAFETY_ANALYSISThread Safety AnalysisYes
CPP_WARN_THREAD_SAFETY_ATTRIBUTESThread Safety AttributesYes
CPP_WARN_THREAD_SAFETY_BETAThread Safety BetaYes
CPP_WARN_THREAD_SAFETY_NEGATIVEThread Safety NegativeYes
CPP_WARN_THREAD_SAFETY_PRECISEThread Safety PreciseYes
CPP_WARN_THREAD_SAFETY_REFERENCEThread Safety ReferenceYes
CPP_WARN_THREAD_SAFETY_VERBOSEThread Safety VerboseYes
CPP_WARN_TRIGRAPHSTrigraphsYesHigh
CPP_WARN_TYPE_SAFETYType SafetyYesHigh
CPP_WARN_TYPEDEF_REDEFINITIONTypedef RedefinitionYesHigh
CPP_WARN_TYPENAME_MISSINGTypename MissingYesHigh
CPP_WARN_UNABLE_TO_OPEN_STATS_FILEUnable to Open Stats FileYes
CPP_WARN_UNALIGNED_ACCESSUnaligned AccessYes
CPP_WARN_UNALIGNED_QUALIFIER_IMPLICIT_CASTUnaligned Qualifier Implicit CastYes
CPP_WARN_UNDEFUndefined MacrosYes
CPP_WARN_UNDEF_PREFIXUndefined Macros of a Certain PrefixYes
CPP_WARN_UNDEFINED_BOOL_CONVERSIONUndefined Bool ConversionYesHigh
CPP_WARN_UNDEFINED_FUNC_TEMPLATEUndefined Function TemplateYes
CPP_WARN_UNDEFINED_INLINEUndefined InlineYesHigh
CPP_WARN_UNDEFINED_INTERNALUndefined InternalYesHigh
CPP_WARN_UNDEFINED_INTERNAL_TYPEUndefined Internal TypeYes
CPP_WARN_UNDEFINED_REINTERPRET_CASTUndefined Reinterpret CastYes
CPP_WARN_UNDEFINED_VAR_TEMPLATEUndefined Var TemplateYesHigh
CPP_WARN_UNDERALIGNED_EXCEPTION_OBJECTUnderaligned Exception ObjectYes
CPP_WARN_UNEVALUATED_EXPRESSIONUnevaluated ExpressionYesHigh
CPP_WARN_UNGUARDED_AVAILABILITYUnguarded AvailabilityYes
CPP_WARN_UNGUARDED_AVAILABILITY_NEWUnguarded Availability NewYesHigh
CPP_WARN_UNICODEUnicode Escape SequencesYesHigh
CPP_WARN_UNICODE_HOMOGLYPHUnicode HomoglyphYesHigh
CPP_WARN_UNICODE_WHITESPACEUnicode WhitespaceYesHigh
CPP_WARN_UNICODE_ZERO_WIDTHUnicode Zero WidthYesHigh
CPP_WARN_UNINITIALIZEDUninitializedYes
CPP_WARN_UNINITIALIZED_CONST_REFERENCEUninitialized Const ReferenceYes
CPP_WARN_UNKNOWN_ARGUMENTUnknown ArgumentYes
CPP_WARN_UNKNOWN_ASSUMPTIONUnknown AssumptionYes
CPP_WARN_UNKNOWN_ATTRIBUTESUnknown AttributesYes
CPP_WARN_UNKNOWN_DIRECTIVESUnknown DirectivesYesHigh
CPP_WARN_UNKNOWN_ESCAPE_SEQUENCEUnknown Escape SequenceYesHigh
CPP_WARN_UNKNOWN_PRAGMASUnknown PragmasYes
CPP_WARN_UNKNOWN_SANITIZERSUnknown SanitizersYes
CPP_WARN_UNKNOWN_WARNING_OPTIONUnknown Warning OptionYes
CPP_WARN_UNNAMED_TYPE_TEMPLATE_ARGSUnnamed Type Template ArgsYes
CPP_WARN_UNNEEDED_INTERNAL_DECLARATIONUnneeded Internal DeclarationYes
CPP_WARN_UNNEEDED_MEMBER_FUNCTIONUnneeded Member FunctionYes
CPP_WARN_UNQUALIFIED_STD_CAST_CALLUnqualified Standard Cast CallYesHigh
CPP_WARN_UNREACHABLE_CODEUnreachable CodeYes
CPP_WARN_UNREACHABLE_CODE_BREAKUnreachable Code BreakYes
CPP_WARN_UNREACHABLE_CODE_FALLTHROUGHUnreachable Code FallthroughYes
CPP_WARN_UNREACHABLE_CODE_GENERIC_ASSOCUnreachable Code Generic AssocYes
CPP_WARN_UNREACHABLE_CODE_LOOP_INCREMENTUnreachable Code Loop IncrementYes
CPP_WARN_UNREACHABLE_CODE_RETURNUnreachable Code ReturnYes
CPP_WARN_UNSEQUENCEDUnsequenced ModificationsYesHigh
CPP_WARN_UNSUPPORTED_ABIUnsupported ABI (Application Binary Interface)Yes
CPP_WARN_UNSUPPORTED_ABSUnsupported Absolute Value ArgumentYes
CPP_WARN_UNSUPPORTED_AVAILABILITY_GUARDUnsupported Availability GuardYesHigh
CPP_WARN_UNSUPPORTED_CBUnsupported Compact BranchesYes
CPP_WARN_UNSUPPORTED_DLL_BASE_CLASS_TEMPLATEUnsupported DLL Base Class TemplateYes
CPP_WARN_UNSUPPORTED_FLOATING_POINT_OPTUnsupported Floating Point OptionYes
CPP_WARN_UNSUPPORTED_FRIENDUnsupported FriendYesHigh
CPP_WARN_UNSUPPORTED_GPOPTUnsupported GPopt (Gaussian Process Optimization)Yes
CPP_WARN_UNSUPPORTED_NANUnsupported Nan ArgumentYes
CPP_WARN_UNSUPPORTED_TARGET_OPTUnsupported Target OptionYes
CPP_WARN_UNSUPPORTED_VISIBILITYUnsupported VisibilityYes
CPP_WARN_UNUSABLE_PARTIAL_SPECIALIZATIONUnusable Partial SpecializationYes
CPP_WARN_UNUSED_BUT_SET_PARAMETERUnused but Set ParameterYes
CPP_WARN_UNUSED_BUT_SET_VARIABLEUnused but Set VariableYes
CPP_WARN_UNUSED_COMMAND_LINE_ARGUMENTUnused Command Line ArgumentYes
CPP_WARN_UNUSED_COMPARISONUnused ComparisonYesHigh
CPP_WARN_UNUSED_CONST_VARIABLEUnused Const VariableYes
CPP_WARN_UNUSED_EXCEPTION_PARAMETERUnused Exception ParameterYes
CPP_WARN_UNUSED_FUNCTIONUnused FunctionYes
CPP_WARN_UNUSED_GETTER_RETURN_VALUEUnused Getter Return ValueYes
CPP_WARN_UNUSED_LABELUnused LabelYes
CPP_WARN_UNUSED_LAMBDA_CAPTUREUnused Lambda CaptureYes
CPP_WARN_UNUSED_LOCAL_TYPEDEFUnused Local TypedefYes
CPP_WARN_UNUSED_MACROSUnused MacrosYes
CPP_WARN_UNUSED_MEMBER_FUNCTIONUnused Member FunctionYes
CPP_WARN_UNUSED_PARAMETERUnused ParameterYes
CPP_WARN_UNUSED_PRIVATE_FIELDUnused Private FieldYes
CPP_WARN_UNUSED_PROPERTY_IVARUnused Property IVar (Instance Variable)Yes
CPP_WARN_UNUSED_RESULTUnused ResultYesHigh
CPP_WARN_UNUSED_TEMPLATEUnused TemplateYes
CPP_WARN_UNUSED_VALUEUnused ValueYesHigh
CPP_WARN_UNUSED_VARIABLEUnused VariableYes
CPP_WARN_UNUSED_VOLATILE_LVALUEUnused Volatile LvalueYesHigh
CPP_WARN_USED_BUT_MARKED_UNUSEDUsed but Marked UnusedYes
CPP_WARN_USER_DEFINED_LITERALSUser Defined LiteralsYesHigh
CPP_WARN_USER_DEFINED_WARNINGSUser Defined WarningsYes
CPP_WARN_VARARGSVariadic ArgumentsYesHigh
CPP_WARN_VARIADIC_MACROSVariadic MacrosYes
CPP_WARN_VEC_ELEM_SIZEVector Element SizeYes
CPP_WARN_VECTOR_CONVERSIONVector ConversionYes
CPP_WARN_VEXING_PARSEVexing Parse OccurrencesYesHigh
CPP_WARN_VISIBILITYVisibility of DeclarationsYesHigh
CPP_WARN_VLAVLA (Variable Length Array)Yes
CPP_WARN_VLA_EXTENSIONVLA (Variable Length Array) ExtensionYes
CPP_WARN_VOID_POINTER_TO_ENUM_CASTVoid Pointer to Enum CastYesHigh
CPP_WARN_VOID_POINTER_TO_INT_CASTVoid Pointer to Int CastYesHigh
CPP_WARN_VOID_PTR_DEREFERENCEVoid Pointer DereferenceYesHigh
CPP_WARN_WARNINGSPreprocessor #WarningsYes
CPP_WARN_WASM_EXCEPTION_SPECWasm Exception SpecYes
CPP_WARN_WEAK_VTABLESWeak VTables (Virtual Tables)Yes
CPP_WARN_WRITABLE_STRINGSWritable StringsYesHigh
CPP_WARN_XOR_USED_AS_POWXor Used as PowerYesHigh
CPP_WARN_ZERO_AS_NULL_POINTER_CONSTANTZero as Null Pointer ConstantYes
CPP_WARN_ZERO_LENGTH_ARRAYZero Length ArrayYes
CRITICAL_PATH_CMPCritical Path ComparisonYesInformational
CSHARP_N000Naming Convention: ClassesYes
CSHARP_N001Naming Convention: ConstsYes
CSHARP_N002Naming Convention: EnumeratorsYes
CSHARP_N003Naming Convention: EventsYes
CSHARP_N004Naming Convention: FieldsYes
CSHARP_N005Naming Convention: FilesYes
CSHARP_N006Naming Convention: IndexersYes
CSHARP_N007Naming Convention: MethodsYes
CSHARP_N008Naming Convention: NamespacesYes
CSHARP_N009Naming Convention: ParametersYes
CSHARP_N010Naming Convention: PropertiesYes
CSHARP_N011Naming Convention: TypeYes
CSHARP_N012Naming Convention: VariablesYes
DCL30-C-BDeclare objects with appropriate storage durations - returning addressesYesHigh
DCL41-CDo not declare variables inside a switch statement before the first case labelYesMedium
ERR33-CDetect and handle standard library errorsYesHigh
ERR34-CDetect errors when converting a string to a numberYesMedium
EXP30-C-BDo not depend on the order of evaluation for side effects - otherYesMedium
EXP32-CDo not access a volatile object through a nonvolatile referenceYesLow
EXP42-CDo not compare padding dataYesMedium
FIO38-CDo not copy a FILE objectYesLow
FLP30-CDo not use floating-point variables as loop countersYesLow
FLP37-CDo not use object representations to compare floating-point valuesYesLow
FORTRAN_N000Naming Convention: Block DataYes
FORTRAN_N001Naming Convention: Common EntitiesYes
FORTRAN_N002Naming Convention: Dummy ArgumentsYes
FORTRAN_N003Naming Convention: EntriesYes
FORTRAN_N004Naming Convention: FunctionsYes
FORTRAN_N005Naming Convention: InterfacesYes
FORTRAN_N006Naming Convention: Main ProgramsYes
FORTRAN_N007Naming Convention: ModulesYes
FORTRAN_N008Naming Convention: Pointer BlocksYes
FORTRAN_N009Naming Convention: SubroutinesYes
FORTRAN_N010Naming Convention: TypesYes
FORTRAN_N011Naming Convention: VariablesYes
INT33-CDivision by ZeroYesLow
INT36-CConverting a pointer to integer or integer to pointerYesLow
JAVA_01All fixed values will be defined final.Yes
JAVA_02Unused Instance Variables.Yes
JAVA_03Single exit point at endYes
JAVA_04Defined methods shall be called at least once.Yes
JAVA_05Unused Local VariablesYes
JAVA_06Package names shall be in all lowercase alphabetic characters and integersYes
JAVA_07If multiple classes are imported, the list shall be imported alphabetically Yes
JAVA_08Each package group shall be separated with a newline Yes
JAVA_09Each Java class shall be assigned to a named package Yes
JAVA_10Use package names instead of prefixes on class identifiers Yes
JAVA_11A class shall be declared an interface if no method of the class is implemented. Yes
JAVA_12If a constructor catches an exception that causes the failure of the object, that exception shall be thrown. Yes
JAVA_13Order class definitions by scope Yes
JAVA_14Capitalize classes and interfaces Yes
JAVA_15Method names should be camelCase Yes
JAVA_16Prepend method names with "get" if they return data member values Yes
JAVA_17Prepend method names with "set" if they assign data member values Yes
JAVA_18Any method that tests the truth or falsity of a condition shall be prepended with a boolean expressionYes
JAVA_19A method definition statement and member (nested) class definition statement shall begin at the standard indentation relative to the enclosing class definition statement.Yes
JAVA_20The last call of the finalizer shall be to super.finalize(), unless Object is the immediate superclassYes
JAVA_21Finalizers shall catch and manage their own exceptions as well as any propagated exceptions that may be thrown from functions called by the finalizer.Yes
JAVA_22A variable’s use shall not be redefined within a method.Yes
JAVA_23Only one variable shall be specified for every declaration key word.Yes
JAVA_24Each new block shall be indented one increment further than its parent block.Yes
JAVA_25Each statement shall be indented to the level of its block.Yes
JAVA_26There shall be at most one statement per line.Yes
JAVA_27A wrapped line shall be indented one increment further than its originating line.Yes
JAVA_28A new instance of java.lang.Exception shall not be thrown. Yes
JAVA_29Braces shall be used for all control structures, even if there is only one statement. Yes
JAVA_30White space before a comma or semicolon shall not be used.Yes
JAVA_31The loop control variable shall not be modified in the body of a for loop.Yes
JAVA_32The last choice of a switch or case statement shall end with a break statement.Yes
JAVA_33Statements under case labels shall be indented one level.Yes
JAVA_34In a switch statement, when a default case is presented, it shall be the last case.Yes
JAVA_35For a do-while loop, the ending brace shall be on the same line as the while.Yes
JAVA_36Ternary operators shall not be nested inside other ternary operators. Yes
JAVA_37Calculations that resolve to the same value shall not be performed inside a loop. Yes
JAVA_38 For the control structures the terminating brace shall appear on a separate line at the same indentation as the initiating keyword. Yes
JAVA_39White space shall not be used: between the name of an array and open bracket that introduces its index (e.g., array[i]), or between unary operators and the objects they operate on (e.g., -1). Yes
JAVA_40Spaces shall be placed after commas.Yes
JAVA_41Any method that returns the object converted to another type shall be prepended with the word "to" (e.g., c.toString()). Yes
JAVA_42The end of a closing brace shall be at the same indentation as the blocks' declaring line. Yes
JAVA_43Method declarations shall have at least one blank line between them to improve readability. Yes
JAVA_44Spaces shall be placed around all binary operators. Yes
JAVA_DCL00Prevent class initialization cyclesYes
JAVA_DCL02Do not modify the collection's elements during an enhanced for statementYes
JAVA_ENV02Do not trust the values of environment variablesYes
JAVA_ENV03Do not grant dangerous combinations of permissionsYes
JAVA_ENV06Production code must not contain debugging entry pointsYes
JAVA_ERR00Do not suppress or ignore checked exceptionsYes
JAVA_ERR01Do not allow exceptions to expose sensitive informationYes
JAVA_ERR02Prevent exceptions while logging dataYes
JAVA_ERR03Restore prior object state on method failureYes
JAVA_ERR04Do not complete abruptly from a finally blockYes
JAVA_ERR05Do not let checked exceptions escape from a finally blockYes
JAVA_ERR06Do not throw undeclared checked exceptionsYes
JAVA_ERR07Do not throw RuntimeException, Exception, or ThrowableYes
JAVA_ERR08Do not catch NullPointerException or any of its ancestorsYes
JAVA_ERR09Do not allow untrusted code to terminate the JVMYes
JAVA_EXP00Do not ignore values returned by methods.Yes
JAVA_EXP02Do not use the Object.equals() method to compare two arrays.Yes
JAVA_EXP03Do not use the equality operators when comparing values of boxed primitivesYes
JAVA_EXP04Do not pass arguments to certain Java Collections Framework methods that are a different type than the collection parameter typeYes
JAVA_EXP05Do not follow a write by a subsequent write or read of the same object within an expressionYes
JAVA_EXP06Expressions used in assertions must not produce side effectsYes
JAVA_FIO00Do not operate on files in shared directoriesYes
JAVA_FIO01Create files with appropriate access permissionsYes
JAVA_FIO02Detect and handle file-related errorsYes
JAVA_FIO03Remove temporary files before terminationYes
JAVA_FIO04Release resources when they are no longer neededYes
JAVA_FIO05Do not expose buffers or their backing arrays methods to untrusted codeYes
JAVA_FIO09Do not rely on the write() method to output integers outside the range 0 to 255Yes
JAVA_FIO10Ensure the array is filled when using read() to fill an arrayYes
JAVA_FIO13Do not log sensitive information outside a trust boundaryYes
JAVA_FIO14Perform proper cleanup at program terminationYes
JAVA_IDS00Prevent SQL InjectionYes
JAVA_IDS01Normalize strings before validating themYes
JAVA_IDS04Safely extract files from ZipInputStreamYes
JAVA_IDS06Exclude unsanitized user input from format stringsYes
JAVA_IDS08Sanitize untrusted data included in a regular expressionYes
JAVA_IDS11Perform any string modifications before validationYes
JAVA_IDS16Prevent XML InjectionYes
JAVA_JNI00Define wrappers around native methodsYes
JAVA_LCK00Use private final lock objects to synchronize classes that may interact with untrusted codeYes
JAVA_LCK01Do not synchronize on objects that may be reusedYes
JAVA_LCK02Do not synchronize on the class object returned by getClass()Yes
JAVA_LCK04Do not synchronize on a collection view if the backing collection is accessibleYes
JAVA_LCK05Synchronize access to static fields that can be modified by untrusted codeYes
JAVA_LCK06Do not use an instance lock to protect shared static dataYes
JAVA_LCK07Avoid deadlock by requesting and releasing locks in the same orderYes
JAVA_LCK08Ensure actively held locks are released on exceptional conditionsYes
JAVA_LCK09Do not perform operations that can block while holding a lockYes
JAVA_LCK10Use a correct form of the double-checked locking idiomYes
JAVA_LCK11Avoid client-side locking when using classes that do not commit to their locking strategyYes
JAVA_MET00Validate method argumentsYes
JAVA_MET01Never use assertions to validate method argumentsYes
JAVA_MET02Do not use deprecated or obsolete classes or methodsYes
JAVA_MET03Methods that perform a security check must be declared private or final.Yes
JAVA_MET04Do not increase the accessibility of overridden or hidden methodsYes
JAVA_MET05Ensure that constructors do not call overridable methodsYes
JAVA_MET06Do not invoke overridable methods in clone()Yes
JAVA_MET07Never declare a class method that hides a method declared in a superclass or superinterfaceYes
JAVA_MET08Preserve the equality contract when overriding the equals() methodYes
JAVA_MET09Classes that define an equals() method must also define a hashCode() methodYes
JAVA_MET10Follow the general contract when implementing the compareTo() methodYes
JAVA_MET11Ensure that keys used in comparison operations are immutableYes
JAVA_MET12Do not use finalizersYes
JAVA_MSC00Use SSLSocket rather than Socket for secure data exchangeYes
JAVA_MSC01Do not use an empty infinite loopYes
JAVA_MSC02Generate strong random numbersYes
JAVA_N000Naming Convention: ClassesYes
JAVA_N001Naming Convention: FilesYes
JAVA_N002Naming Convention: InterfaceYes
JAVA_N003Naming Convention: MethodsYes
JAVA_N004Naming Convention: PackagesYes
JAVA_N005Naming Convention: ParametersYes
JAVA_N006Naming Convention: VariablesYes
JAVA_N007Constants shall be in all uppercase, with underscores separating each component wordYes
JAVA_NUM00Detect or prevent integer overflowYes
JAVA_NUM02Ensure that division and remainder operations do not result in divide-by-zero errorsYes
JAVA_NUM07Do not attempt comparisons with NaNYes
JAVA_NUM09Do not use floating-point variables as loop countersYes
JAVA_NUM10Do not construct BigDecimal objects from floating-point literalsYes
JAVA_NUM11Do not compare or inspect the string representation of floating-point valuesYes
JAVA_NUM12Ensure conversions of numeric types to narrower types do not result in lost or misinterpreted dataYes
JAVA_NUM13Avoid loss of precision when converting primitive integers to floating-pointYes
JAVA_OBJ01Limit accessibility of fieldsYes
JAVA_OBJ04Provide mutable classes with copy functionality to safely allow passing instances to untrusted codeYes
JAVA_OBJ05Do not return references to private mutable class membersYes
JAVA_OBJ07Sensitive classes must not let themselves be copiedYes
JAVA_OBJ08Do not expose private members of an outer class from within a nested classYes
JAVA_OBJ09Compare classes and not class namesYes
JAVA_OBJ10Do not use public static nonfinal fieldsYes
JAVA_OBJ11Be wary of letting constructors throw exceptionsYes
JAVA_OBJ13Ensure that references to mutable objects are not exposedYes
JAVA_SEC01Do not allow tainted variables in privileged blocksYes
JAVA_SEC07Call the superclass's getPermissions() method when writing a custom class loaderYes
JAVA_SER01Do not deviate from the proper signatures of serialization methodsYes
JAVA_SER04Do not allow serialization and deserialization to bypass the security managerYes
JAVA_SER05Do not serialize instances of inner classesYes
JAVA_SER06Make defensive copies of private mutable components during deserializationYes
JAVA_SER07Do not use the default serialized form for classes with implementation-defined invariantsYes
JAVA_SER09Do not invoke overridable methods from the readObject() methodYes
JAVA_SER12Prevent deserialization of untrusted dataYes
JAVA_STR01Do not assume that a Java char fully represents a Unicode code pointYes
JAVA_STR03Do not encode noncharacter data as a stringYes
JAVA_THI00Do not invoke Thread.run()Yes
JAVA_THI01Do not invoke ThreadGroup methodsYes
JAVA_THI02Notify all waiting threads rather than a single thread.Yes
JAVA_THI03Always invoke wait() and await() methods inside a loopYes
JAVA_THI04Ensure that threads performing blocking operations can be terminatedYes
JAVA_THI05Do not use Thread.stop() to terminate threads.Yes
JAVA_TPS00Use thread pools to enable graceful degradation of service during traffic burstsYes
JAVA_TPS01Do not execute interdependent tasks in a bounded thread poolYes
JAVA_TPS02Ensure that tasks submitted to a thread pool are interruptibleYes
JAVA_TPS03Ensure that tasks executing in a thread pool do not fail silentlyYes
JAVA_TPS04Ensure ThreadLocal variables are reinitialized when using thread poolsYes
JAVA_TSM00Do not override thread-safe methods with methods that are not thread-safeYes
JAVA_TSM01Do not let the this reference escape during object constructionYes
JAVA_TSM02Do not use background threads during class initializationYes
JAVA_TSM03Do not publish partially initialized objectsYes
JAVA_VNA00Ensure visibility when accessing shared primitive variablesYes
JAVA_VNA01Ensure visibility of shared references to immutable objectsYes
JAVA_VNA02Ensure that compound operations on shared variables are atomicYes
JAVA_VNA03Do not assume that a group of calls to independently atomic methods is atomicYes
JAVA_VNA04Ensure that calls to chained methods are atomicYes
JAVA_VNA05Ensure atomicity when reading and writing 64-bit valuesYes
METRIC_00Program Unit Call CountYes
METRIC_01Program Unit Callby CountYes
METRIC_02Program Unit Comment to Code RatioYes
METRIC_03Program Unit Cyclomatic ComplexityYes
METRIC_04Program Unit Max LengthYes
METRIC_05Program Unit Max Nesting DepthYes
METRIC_06Program Unit Parameters CountYes
METRIC_07Program Unit Path CountYes
METRIC_08Program Unit Statement CountYes
METRIC_09Coupling Between Object ClassesYes
METRIC_10Coupled PackagesYes
METRIC_11Depth of Inheritance TreeYes
METRIC_12Lack of Cohesion in MethodsYes
METRIC_13Maintainability IndexYes
MSC30-CDo not use the rand() function for generating pseudorandom numbersYesMedium
POS44-CDo not use signals to terminate threadsYesLow
POS47-CDo not use threads that can be canceled asynchronouslyYesMedium
PrintUncommented Print StatementsYes
PYTH_01Unnecessary ImportsYes
RECOMMENDED_00Commented Out CodeYes
RECOMMENDED_01Definitions in Header FilesYes
RECOMMENDED_02Files too longYes
RECOMMENDED_03Floating Equality TestYes
RECOMMENDED_04Functions Too LongYes
RECOMMENDED_05Functions shall not be declared implicitlyYes
RECOMMENDED_06Goto StatementsYes
RECOMMENDED_07Macros shall not be #define'd or #undef'd within a blockYes
RECOMMENDED_08Magic NumbersYes
RECOMMENDED_09Nested CommentsYes
RECOMMENDED_10Overly Complex FunctionsYes
RECOMMENDED_11Trigraphs shall not be usedYes
RECOMMENDED_12Unreachable CodeYes
RECOMMENDED_13Unused FunctionsYes
RECOMMENDED_14Unused C and C++ Local VariablesYes
RECOMMENDED_15Unused Static GlobalsYes
RECOMMENDED_16Variables should be commentedYes
RECOMMENDED_17Upper limit shall not be modified within the bounds of the loopYes
RECOMMENDED_18Unused Local VariablesYes
RECOMMENDED_19Comments Indicating Future FixesYes
RECOMMENDED_20Duplicate CodeYes
STI_DATA_RACEData RaceYesInformational
STR38-CDo not confuse narrow and wide character strings and functionsYesHigh
UND_ERRORAnalysis ErrorYesUrgent
UND_WARNINGAnalysis WarningYes
VHDL_1VHDL_1 Unused declarationsYes
VHDL_2VHDL_2 Unconnected input portsYes
VHDL_3VHDL_3 Unconnected output portsYes
VHDL_4VHDL_4 Incomplete sensitivity lists shall not contain signals not needed by processNo
VHDL_5VHDL_5 Processes and for loops without labelsYes
VHDL_6VHDL_6 Inference of latchesYes
VHDL_7VHDL_7 Multiple driversYes
VHDL_8VHDL_8 Hard coded numeric valuesYes
VHDL_9VHDL_9 Duplicate signal assignmentsYes
VHDL_10VHDL_10 Signals not initialized before useYes
VHDL_11VHDL_11 Nested case statementsYes
VHDL_12VHDL_12 Commented out codeYes
VHDL_13VHDL_13 Cyclomatic ComplexityYes
VHDL_14VHDL_14 Functions shall not have more than 8 input parametersYes
VHDL_15VHDL_15 Source code line length shall not exceed 150 charactersYes
VHDL_16VHDL_16 Tabs shall not be used for indentationYes
VHDL_17VHDL_17 Files shall not have more than 4500 executable statementsYes
VHDL_18VHDL_18 There shall not be multiple statements on a single lineYes
VHDL_19VHDL_19 Else and Elsif statements shall be on their own linesYes
VHDL_20VHDL_20 Nested if statementsYes
VHDL_21VHDL_21 Duplicate statements in a case statementYes
VHDL_22VHDL_22 Incomplete case statementsYes
VHDL_23VHDL_23 Unreachable case itemsNo
VHDL_24VHDL_24 Do not use While loopYes
VHDL_25VHDL_25 Do not use Loop without ForYes
VHDL_26VHDL_26 Do not use WaitYes
VHDL_27VHDL_27 Do not use DelayYes
VHDL_28VHDL_28 Unlabeled ProcessesYes
VHDL_N001Naming Convention: ArchitecturesYes
VHDL_N002Naming Convention: ConfigurationsYes
VHDL_N003Naming Convention: EntitiesYes
VHDL_N004Naming Convention: FilesYes
VHDL_N005Naming Convention: PackagesYes
VHDL_N006Naming Convention: ProcessesYes
VHDL_N007Naming Convention: SubtypesYes
VHDL_N008Naming Convention: TypesYes
VHDL_N009Naming Convention: FunctionsYes
VHDL_N010Naming Convention: SignalsYes