# This file was generated from template 'codesonar/presets/jsf++_inc.conf.in' # # This preset configures CodeSonar to generate warnings for various # JSF++ rules # Specifically, it enables CodeSonar warning classes that # - correspond to JSF++ guidelines, AND # - have checks that are compatible with incremental build/analysis. SCOPE_CHECK_SUGGESTS_LOCAL_STATIC = Yes BOOL_TYPES += bool,true,false # Custom setting for # JSF++:1 "Any one function (or method) will contain no more than 200 logical source lines of code (LSLOCs)." MAX_FUNCTION_LENGTH = 200 # Custom settings for # JSF++:46 "User-specified identifiers (internal and external) will not rely on significance of more than 64 characters." SIGNIFICANCE_LEN_EXTERN = 64 SIGNIFICANCE_LEN_MACRO = 64 SIGNIFICANCE_LEN_OTHER = 64 # Custom settings for # JSF++:50 "The first word of the name of a class, structure, # namespace, enumeration, or type created with typedef will begin with # an uppercase letter. All other letters will be lowercase." # This requirement also satisfies # JSF++:47 "Identifiers will not begin with the underscore character '_'." IDENTIFIER_NAMING_ABSTRACT_CLASS_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_CLASS_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_ENUM_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_INLINE_NAMESPACE_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_NAMESPACE_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_STRUCT_REGEX = ^[A-Z][^A-Z]*$ IDENTIFIER_NAMING_TYPEDEF_REGEX = ^[A-Z][^A-Z]*$ # Custom settings for # JSF++:51 "All letters contained in function and variable names will be composed entirely of lowercase letters." IDENTIFIER_NAMING_CONSTEXPR_VARIABLE_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_FUNCTION_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_GLOBAL_FUNCTION_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_GLOBAL_VARIABLE_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_LOCAL_VARIABLE_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_STATIC_VARIABLE_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_VARIABLE_REGEX = ^[^A-Z_][^A-Z]*$ # Custom settings for # JSF++:52 "Identifiers for constant and enumerator values shall be lowercase." # in combination with # JSF++:47 "Identifiers will not begin with the underscore character '_'." IDENTIFIER_NAMING_CLASS_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_ENUM_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_GLOBAL_CONSTANT_POINTER_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_GLOBAL_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_LOCAL_CONSTANT_POINTER_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_LOCAL_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ IDENTIFIER_NAMING_STATIC_CONSTANT_REGEX = ^[^A-Z_][^A-Z]*$ # Custom settings for # JSF++:47 "Identifiers will not begin with the underscore character '_'." # (for all identifier types not already covered) IDENTIFIER_NAMING_CLASS_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CLASS_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CONSTANT_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CONSTANT_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CONSTANT_POINTER_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CONSTEXPR_FUNCTION_REGEX = ^[^_].*$ IDENTIFIER_NAMING_CONSTEXPR_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_GLOBAL_POINTER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_LOCAL_POINTER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_MACRO_DEFINITION_REGEX = ^[^_].*$ IDENTIFIER_NAMING_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PARAMETER_PACK_REGEX = ^[^_].*$ IDENTIFIER_NAMING_POINTER_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PRIVATE_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PRIVATE_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PROTECTED_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PROTECTED_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PUBLIC_MEMBER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_PUBLIC_METHOD_REGEX = ^[^_].*$ IDENTIFIER_NAMING_TEMPLATE_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_TEMPLATE_TEMPLATE_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_TYPE_ALIAS_REGEX = ^[^_].*$ IDENTIFIER_NAMING_TYPE_TEMPLATE_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_UNION_REGEX = ^[^_].*$ IDENTIFIER_NAMING_VALUE_TEMPLATE_PARAMETER_REGEX = ^[^_].*$ IDENTIFIER_NAMING_VIRTUAL_METHOD_REGEX = ^[^_].*$ # Custom setting for # JSF++:110 "Functions with more than 7 arguments will not be used." MAX_NUM_PARAMS = 7 # Custom setting for # JSF++:169 "Pointers to pointers should be avoided when possible." # # Note that this is a stricter requirement than JSF++:170 "More than 2 # levels of pointer indirection shall not be used." If you want to # satisfy JSF++:170 but not JSF++:169, you can change the setting to # MAX_PERMITTED_INDIRECTION_IN_DECLARATION=2 MAX_PERMITTED_INDIRECTION_IN_DECLARATION = 1 # Explicitly enable all warning classes that correspond to one or more # JSF++ guidelines AND are compatible with incremental # build/analysis, for C++ compilation units. # # (If any of these classes is already enabled for C compilation # units, it will remain enabled.) # # - Some of the JSF++-related classes are enabled by default, but # others are not. Classes that are enabled by default are indicated with a # comment directly above the WARNING_FILTER setting. # - If you also want to enable a class for C compilation units, # delete "language=c++" from the corresponding WARNING_FILTER setting. # # This part of this file was generated from 'cso_wcmanifest.py' # # At least one of the classes enabled by this preset requires unnormalized C ASTs RETAIN_UNNORMALIZED_C_AST = Yes # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Addition Overflow of Allocation Size" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Addition Overflow of Size" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Array to Pointer Decay" language=c++ # JSF++:160: An assignment expression shall be used only as the expression in an expression statement. WARNING_FILTER += allow class="Assignment Result in Expression" language=c++ # JSF++:160: An assignment expression shall be used only as the expression in an expression statement. WARNING_FILTER += allow class="Assignment in Conditional" language=c++ # JSF++:189: The goto statement shall not be used. WARNING_FILTER += allow class="Backwards goto" language=c++ # JSF++:9: Only those characters specified in the C++ basic source character set will be used. WARNING_FILTER += allow class="Bad Token" language=c++ # JSF++:209: The basic types of int, short, long, float and double shall not be used, but specific-length equivalents should be typedef'd accordingly for each compiler, and these type names used in the code. WARNING_FILTER += allow class="Basic Numerical Type Used" language=c++ # JSF++:153: Unions shall not be used. WARNING_FILTER += allow class="Bit-field in Union" language=c++ # JSF++:59: The statements forming the body of an if, else if, else, while, do...while or for statement shall always be enclosed in braces, even if the braces form an empty block. WARNING_FILTER += allow class="Body Is Not Compound Statement" language=c++ # JSF++:195: A switch expression will not represent a Boolean value. WARNING_FILTER += allow class="Boolean switch Expression" language=c++ # JSF++:208: C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.) # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Branch Into Handler" language=c++ # JSF++:208: C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.) # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Branch Into try Block" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Buffer Overrun" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Buffer Underrun" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. # JSF++:185: C++ style casts (const_cast, reinterpret_cast, and static_cast) shall be used instead of the traditional C-style casts. WARNING_FILTER += allow class="C-style Cast" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Cast Alters Value" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast Removes const Qualifier" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast Removes volatile Qualifier" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast: Arithmetic Type/Void Pointer" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast: Non-integer Arithmetic Type/Object Pointer" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast: Object Pointers" language=c++ # JSF++:178: Down casting (casting from base to derived class) shall only be allowed through certain mechanisms. # JSF++:179: A pointer to a virtual base class shall not be converted to a pointer to a derived class. # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast: Virtual Base to Derived" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Cast: reinterpret_cast" language=c++ # JSF++:180: Implicit conversions that may result in a loss of information shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Coercion Alters Value" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Coercion: Integer Constant to Pointer" language=c++ # JSF++:127: Code that is not used (commented out) shall be deleted. WARNING_FILTER += allow class="Commented-out Code" language=c++ # JSF++:171: Relational operators shall not be applied to pointer types except where both operands are of the same type and point to the same entity. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Comparison of Unrelated Pointers" language=c++ # JSF++:14: Literal suffixes shall use uppercase rather than lowercase letters. WARNING_FILTER += allow class="Confusing Literal Suffix" language=c++ # JSF++:159: Operators ||, &&, and unary & shall not be overloaded. WARNING_FILTER += allow class="Confusing Operator Overload" language=c++ # JSF++:190: The continue statement shall not be used. WARNING_FILTER += allow class="Continue Statement" language=c++ # JSF++:177: User-defined conversion functions should be avoided. WARNING_FILTER += allow class="Conversion Operator Not Explicit" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Conversion from Function Pointer" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Conversion to Function Pointer" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Conversion: Pointer to Incomplete" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Conversion: Pointer/Integer" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Conversion: Void Pointer to Object Pointer" language=c++ # JSF++:117.1: An object should be passed as const T& if the function should not change the value of the object. WARNING_FILTER += allow class="Copy Operation Parameter Is Not const" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Dangerous Function Cast" language=c++ # JSF++:53.1: The following character sequences shall not appear in header file names: ', \, /*, //, or ". WARNING_FILTER += allow class="Dangerous Include File Name" language=c++ # JSF++:178: Down casting (casting from base to derived class) shall only be allowed through certain mechanisms. # JSF++:179: A pointer to a virtual base class shall not be converted to a pointer to a derived class. # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Derived Class From Virtual Base" language=c++ # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Double Close" language=c++ # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Double Free" language=c++ # JSF++:206: Allocation/deallocation from/to the free store (heap) shall not occur after initialization. WARNING_FILTER += allow class="Dynamic Allocation After Initialization" language=c++ # JSF++:108: Functions with variable numbers of arguments shall not be used. WARNING_FILTER += allow class="Ellipsis" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). WARNING_FILTER += allow class="Float Multiplication Overflow" language=c++ # JSF++:147: The underlying bit representations of floating point numbers shall not be used in any way by the programmer. # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Float Pointer Conversion" language=c++ # JSF++:197: Floating point variables shall not be used as loop counters. WARNING_FILTER += allow class="Float-typed Loop Counter" language=c++ # JSF++:202: Floating point variables shall not be tested for exact equality or inequality. WARNING_FILTER += allow class="Floating Point Equality" language=c++ # JSF++:187: All non-null statements shall potentially have a side-effect. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Function Call Has No Effect" language=c++ # JSF++:39: Header files (*.h) will not contain non-const variable definitions or function definitions. WARNING_FILTER += allow class="Function Defined in Header File" language=c++ # JSF++:1: Any one function (or method) will contain no more than 200 logical source lines of code (L-SLOCs). WARNING_FILTER += allow class="Function Too Long" language=c++ # JSF++:29: The #define pre-processor directive shall not be used to create inline macros. Inline functions shall be used instead. WARNING_FILTER += allow class="Function-Like Macro" language=c++ # JSF++:189: The goto statement shall not be used. WARNING_FILTER += allow class="Goto Statement" language=c++ # JSF++:3: All functions shall have a cyclomatic complexity number of 20 or less. WARNING_FILTER += allow class="High Cyclomatic Complexity (Procedure)" language=c++ # JSF++:115: If a function returns error information, then that error information will be tested. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Ignored Return Value" language=c++ # JSF++:77.1: The definition of a member function shall not contain default arguments that produce a signature identical to that of the implicitly-declared copy constructor for the corresponding class/structure. WARNING_FILTER += allow class="Implicit Constructor Shadowing" language=c++ # JSF++:88.1: A stateful virtual base shall be explicitly declared in each derived class that accesses it. WARNING_FILTER += allow class="Implicit Inheritance from Stateful Virtual Base" language=c++ # JSF++:82: An assignment operator shall return a reference to *this. WARNING_FILTER += allow class="Inappropriate Assignment Operator Return" language=c++ # JSF++:180: Implicit conversions that may result in a loss of information shall not be used. # JSF++:184: Floating point numbers shall not be converted to integers unless such a conversion is a specified algorithmic requirement or is necessary for a hardware interface. WARNING_FILTER += allow class="Inappropriate Assignment Type" language=c++ # JSF++:154: Bit-fields shall have explicitly unsigned integral or enumeration types only. WARNING_FILTER += allow class="Inappropriate Bit-field Type" language=c++ # JSF++:184: Floating point numbers shall not be converted to integers unless such a conversion is a specified algorithmic requirement or is necessary for a hardware interface. WARNING_FILTER += allow class="Inappropriate Cast Type" language=c++ # JSF++:97.1: Neither operand of an equality operator (== or !=) shall be a pointer to a virtual member function. WARNING_FILTER += allow class="Inappropriate Comparison of Virtual Member Function" language=c++ # JSF++:33: The #include directive shall use the notation to include header files. WARNING_FILTER += allow class="Inappropriate Include File Specification" language=c++ # JSF++:180: Implicit conversions that may result in a loss of information shall not be used. # JSF++:184: Floating point numbers shall not be converted to integers unless such a conversion is a specified algorithmic requirement or is necessary for a hardware interface. WARNING_FILTER += allow class="Inappropriate Numeric Assignment" language=c++ # JSF++:164.1: The left-hand operand of a right-shift operator shall not have a negative value. # JSF++:165: The unary minus operator shall not be applied to an unsigned expression. WARNING_FILTER += allow class="Inappropriate Operand Type" language=c++ # JSF++:17: The error indicator errno shall not be used. WARNING_FILTER += allow class="Inappropriate Test of Error Code" language=c++ # JSF++:205: The volatile keyword shall not be used unless directly interfacing with hardware. WARNING_FILTER += allow class="Inappropriate Volatile Declaration" language=c++ # JSF++:208: C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.) WARNING_FILTER += allow class="Inappropriate throw in noexcept Function" language=c++ # JSF++:145: In an enumerator list, the '=' construct shall not be used to explicitly initialize members other than the first, unless all items are explicitly initialized. WARNING_FILTER += allow class="Inconsistent Enumerator Initialization" language=c++ # JSF++:204.1: The value of an expression shall be the same under any order of evaluation that the standard permits. WARNING_FILTER += allow class="Indeterminate Order of Evaluation" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Integer Overflow of Allocation Size" language=c++ # JSF++:79: All resources acquired by a class shall be released by the class's destructor. # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Leak" language=c++ # JSF++:126: Only valid C++ style comments (//) shall be used. WARNING_FILTER += allow class="Line Splicing in Comment" language=c++ # JSF++:150: Hexadecimal constants will be represented using all uppercase letters. WARNING_FILTER += allow class="Lower Case in Hexadecimal Literal" language=c++ # JSF++:30: The #define pre-processor directive shall not be used to define constant values. Instead, the const qualifier shall be applied to variable declarations to specify constant values. # JSF++:31: The #define pre-processor directive will only be used as part of the technique to prevent multiple inclusions of the same header file. WARNING_FILTER += allow class="Macro Defines Constant" language=c++ # JSF++:33: The #include directive shall use the notation to include header files. WARNING_FILTER += allow class="Malformed #include" language=c++ # JSF++:201: Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop. WARNING_FILTER += allow class="Malformed for-loop Condition" language=c++ # JSF++:198: The initialization expression in a for loop will perform no actions other than to initialize the value of a single for loop parameter. WARNING_FILTER += allow class="Malformed for-loop Initialization" language=c++ # JSF++:199: The increment expression in a for loop will perform no action other than to change a single loop parameter to the next value for the loop. WARNING_FILTER += allow class="Malformed for-loop Step" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Masked by Default Handler" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Masked by Handler" language=c++ # JSF++:95: An inherited default parameter shall never be redefined. WARNING_FILTER += allow class="Method Default Value Mismatch" language=c++ # JSF++:162: Signed and unsigned values shall not be mixed in arithmetic or comparison operations. WARNING_FILTER += allow class="Mismatched Operand Types" language=c++ # JSF++:194: All switch statements that do not intend to test for every enumeration value shall contain a final default clause. WARNING_FILTER += allow class="Misplaced default" language=c++ # JSF++:144: Braces shall be used to indicate and match the structure in the non-zero initialization of arrays and structures. WARNING_FILTER += allow class="Missing Braces in Initialization" language=c++ # JSF++:40: Every implementation file shall include the header files that uniquely define the inline functions, types, and templates used. # "Missing External Declaration" is not enabled by this preset. # - It is not compatible with INCREMENTAL_BUILD=Yes. # JSF++:192: All if, else if constructs will contain either a final else clause or a comment indicating why a final else clause is not necessary. WARNING_FILTER += allow class="Missing Final else" language=c++ # JSF++:158: The operands of a logical && or || shall be parenthesized if the operands contain binary operators. # JSF++:213: No dependence shall be placed on C++'s operator precedence rules, below arithmetic operators, in expressions. WARNING_FILTER += allow class="Missing Parentheses" language=c++ # JSF++:114: All exit points of value-returning functions shall be through return statements. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Missing Return Value" language=c++ # JSF++:68: Unneeded implicitly generated member functions shall be explicitly disallowed. # JSF++:76: A copy constructor and an assignment operator shall be declared for classes that contain pointers to data items or nontrivial destructors. # JSF++:80: The default copy and assignment operators will be used for classes when those operators offer reasonable semantics. WARNING_FILTER += allow class="Missing User-defined Operations" language=c++ # JSF++:193: Every non-empty case clause in a switch statement shall be terminated with a break statement. WARNING_FILTER += allow class="Missing break" language=c++ # JSF++:194: All switch statements that do not intend to test for every enumeration value shall contain a final default clause. WARNING_FILTER += allow class="Missing default" language=c++ # JSF++:200: Null initialize or increment expressions in for loops will not be used; a while loop will be used instead. WARNING_FILTER += allow class="Missing for-loop Step" language=c++ # JSF++:191: The break statement shall not be used (except to terminate the cases of a switch statement). WARNING_FILTER += allow class="Multiple Abnormal Loop Exits" language=c++ # JSF++:152: Multiple variable declarations shall not be allowed on the same line. WARNING_FILTER += allow class="Multiple Declarations On Line" language=c++ # JSF++:40: Every implementation file shall include the header files that uniquely define the inline functions, types, and templates used. WARNING_FILTER += allow class="Multiple Declarations of a Global" language=c++ # JSF++:139: External objects will not be declared in more than one file. # JSF++:40: Every implementation file shall include the header files that uniquely define the inline functions, types, and templates used. # "Multiple External Declarations" is not enabled by this preset. # - It is not compatible with INCREMENTAL_BUILD=Yes. # JSF++:88: Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plus at most one protected implementation. WARNING_FILTER += allow class="Multiple Inheritance with Private Interface Class" language=c++ # JSF++:88: Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plus at most one protected implementation. WARNING_FILTER += allow class="Multiple Inheritance with Protected Interface Class" language=c++ # JSF++:88: Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plus at most one protected implementation. WARNING_FILTER += allow class="Multiple Inheritance with Public Base Class" language=c++ # JSF++:88: Multiple inheritance shall only be allowed in the following restricted form: n interfaces plus m private implementations, plus at most one protected implementation. WARNING_FILTER += allow class="Multiple Inheritance with Too Many Protected Base Classes" language=c++ # JSF++:113: Functions will have a single exit point. WARNING_FILTER += allow class="Multiple Return Statements" language=c++ # JSF++:42: Each expression-statement will be on a separate line. WARNING_FILTER += allow class="Multiple Statements On Line" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Multiplication Overflow of Allocation Size" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Multiplication Overflow of Size" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="NULL Used as Integer" language=c++ # JSF++:47: Identifiers will not begin with the underscore character '_'. # JSF++:50: The first word of the name of a class, structure, namespace, enumeration, or type created with typedef will begin with an uppercase letter. All others letters will be lowercase. # JSF++:51: All letters contained in function and variable names will be composed entirely of lowercase letters. # JSF++:52: Identifiers for constant and enumerator values shall be lowercase. WARNING_FILTER += allow class="Naming Style Violation" language=c++ # JSF++:164: The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the left-hand operand (inclusive). # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Negative Shift Amount" language=c++ # JSF++:107: Functions shall always be declared at file scope. WARNING_FILTER += allow class="Nested Function Declaration" language=c++ # JSF++:151.1: A string literal shall not be modified. WARNING_FILTER += allow class="Non-const String Literal" language=c++ # JSF++:46: User-specified identifiers (internal and external) will not rely on significance of more than 64 characters. # "Non-distinct Identifiers: External Names" is not enabled by this preset. # - It is not compatible with INCREMENTAL_BUILD=Yes. # JSF++:46: User-specified identifiers (internal and external) will not rely on significance of more than 64 characters. WARNING_FILTER += allow class="Non-distinct Identifiers: Macro/Macro" language=c++ # JSF++:46: User-specified identifiers (internal and external) will not rely on significance of more than 64 characters. # "Non-distinct Identifiers: Macro/Other" is not enabled by this preset. # - It is not compatible with INCREMENTAL_BUILD=Yes. # JSF++:135: Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identifier. # JSF++:46: User-specified identifiers (internal and external) will not rely on significance of more than 64 characters. WARNING_FILTER += allow class="Non-distinct Identifiers: Nested Scope" language=c++ # JSF++:46: User-specified identifiers (internal and external) will not rely on significance of more than 64 characters. WARNING_FILTER += allow class="Non-distinct Identifiers: Same Scope" language=c++ # JSF++:115: If a function returns error information, then that error information will be tested. # JSF++:17: The error indicator errno shall not be used. WARNING_FILTER += allow class="Non-zero Error Code" language=c++ # JSF++:17: The error indicator errno shall not be used. WARNING_FILTER += allow class="Non-zero Error Code Assignment" language=c++ # JSF++:218: Compiler warning levels will be set in compliance with project policies. WARNING_FILTER += allow class="Not All Warnings Are Enabled" language=c++ # JSF++:174: The null pointer shall not be de-referenced. # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Null Pointer Dereference" language=c++ # JSF++:39: Header files (*.h) will not contain non-const variable definitions or function definitions. WARNING_FILTER += allow class="Object Defined in Header File" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. # JSF++:96: Arrays shall not be treated polymorphically. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Object Slicing" language=c++ # JSF++:149: Octal constants (other than zero) shall not be used. WARNING_FILTER += allow class="Octal Constant" language=c++ # JSF++:210: Algorithms shall not make assumptions concerning how data is represented in memory (e.g. big endian vs. little endian, base class subobject ordering in derived classes, nonstatic data member ordering across access specifiers, etc.) # JSF++:210.1: Algorithms shall not make assumptions concerning the order of allocation of nonstatic data members separated by an access specifier. # JSF++:75: Members of the initialization list shall be listed in the order in which they are declared in the class. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Out of Order Member Initializers" language=c++ # JSF++:94: An inherited nonvirtual function shall not be redefined in a derived class. WARNING_FILTER += allow class="Override of Non-Virtual Method" language=c++ # JSF++:144: Braces shall be used to indicate and match the structure in the non-zero initialization of arrays and structures. WARNING_FILTER += allow class="Partially Uninitialized Aggregate" language=c++ # JSF++:144: Braces shall be used to indicate and match the structure in the non-zero initialization of arrays and structures. WARNING_FILTER += allow class="Partially Uninitialized Array" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # JSF++:215: Pointer arithmetic will not be used. WARNING_FILTER += allow class="Pointer Arithmetic" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. WARNING_FILTER += allow class="Pointer Before Beginning of Object" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Pointer Conversion Loses Bits" language=c++ # JSF++:182: Type casting from any type to or from pointers shall not be used. # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Pointer Conversion to Same Size Integer" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. WARNING_FILTER += allow class="Pointer Past End of Object" language=c++ # JSF++:119: Functions shall not call themselves, either directly or indirectly (i.e. recursion shall not be allowed). WARNING_FILTER += allow class="Recursion" language=c++ # JSF++:187: All non-null statements shall potentially have a side-effect. # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Redundant Condition" language=c++ # JSF++:140: The register storage class specifier shall not be used. WARNING_FILTER += allow class="Register Keyword" language=c++ # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Return Pointer to Freed" language=c++ # JSF++:111: A function shall not return a pointer or reference to a non-static local object. # JSF++:173: The address of an object with automatic storage shall not be assigned to an object which persists after the object has ceased to exist. # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Return Pointer to Local" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. WARNING_FILTER += allow class="Risky Integer Promotion" language=c++ # JSF++:136: Declarations should be at the smallest feasible scope. # JSF++:137: All declarations at file scope should be static where possible. WARNING_FILTER += allow class="Scope Could Be File Static" language=c++ # JSF++:136: Declarations should be at the smallest feasible scope. WARNING_FILTER += allow class="Scope Could Be Local Static" language=c++ # JSF++:164: The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the left-hand operand (inclusive). # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Shift Amount Exceeds Bit Width" language=c++ # JSF++:157: The right hand operand of a && or || operator shall not contain side effects. WARNING_FILTER += allow class="Side Effects in Logical Operand" language=c++ # JSF++:166: The sizeof operator will not be used on expressions that contain side effects. WARNING_FILTER += allow class="Side Effects in sizeof" language=c++ # JSF++:104: A template specialization shall be declared before its use. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Specialization after Use" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Subtraction Underflow of Allocation Size" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Subtraction Underflow of Size" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Tainted Buffer Access" language=c++ # JSF++:196: Every switch statement will have at least two cases and a potential default. WARNING_FILTER += allow class="Too Few Cases in switch" language=c++ # JSF++:110: Functions with more than 7 arguments will not be used. WARNING_FILTER += allow class="Too Many Parameters" language=c++ # JSF++:204: A single operation with side-effects shall only be used in certain contexts. WARNING_FILTER += allow class="Too Many Side Effects in Assignment" language=c++ # JSF++:204: A single operation with side-effects shall only be used in certain contexts. WARNING_FILTER += allow class="Too Many Side Effects in Condition" language=c++ # JSF++:204: A single operation with side-effects shall only be used in certain contexts. WARNING_FILTER += allow class="Too Many Side Effects in Function Call" language=c++ # JSF++:204: A single operation with side-effects shall only be used in certain contexts. WARNING_FILTER += allow class="Too Many Side Effects in Statement" language=c++ # JSF++:204: A single operation with side-effects shall only be used in certain contexts. WARNING_FILTER += allow class="Too Many Side Effects in Switch" language=c++ # JSF++:169: Pointers to pointers should be avoided when possible. # JSF++:170: More than 2 levels of pointer indirection shall not be used. WARNING_FILTER += allow class="Too Much Indirection in Declaration" language=c++ # JSF++:11: Trigraphs will not be used. WARNING_FILTER += allow class="Trigraph" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Truncation of Allocation Size" language=c++ # JSF++:203: Evaluation of expressions shall not lead to overflow/underflow (unless required algorithmically and then should be heavily documented). # JSF++:212: Underflow or overflow functioning shall not be depended on in any special way. WARNING_FILTER += allow class="Truncation of Size" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Type Overrun" language=c++ # JSF++:211: Algorithms shall not assume that shorts, ints, longs, floats, doubles or long doubles begin at particular addresses. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Type Underrun" language=c++ # JSF++:48: Identifiers will not be typographically ambiguous. # "Typographically Ambiguous Identifiers" is not enabled by this preset. # - It is not compatible with INCREMENTAL_BUILD=Yes. # JSF++:174: The null pointer shall not be de-referenced. WARNING_FILTER += allow class="Unchecked Parameter Dereference" language=c language=c++ # JSF++:142: All variables shall be initialized before use. # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # JSF++:71: Calls to an externally visible operation of an object, other than its constructors, shall not be allowed until the object has been fully initialized. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Uninitialized Variable" language=c++ # JSF++:153: Unions shall not be used. WARNING_FILTER += allow class="Union Type" language=c++ # JSF++:156: All the members of a structure (or class) shall be named and shall only be accessed via their names. WARNING_FILTER += allow class="Unnamed Field" language=c++ # JSF++:68: Unneeded implicitly generated member functions shall be explicitly disallowed. WARNING_FILTER += allow class="Unneeded Implicitly Generated Operations" language=c++ # JSF++:214: Assuming that non-local static objects, in separate translation units, are initialized in a special order shall not be done. WARNING_FILTER += allow class="Unordered Initialization" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Unreachable Call" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Unreachable Computation" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Unreachable Conditional" language=c++ # JSF++:186: There shall be no unreachable code. WARNING_FILTER += allow class="Unreachable Control Flow" language=c++ # JSF++:186: There shall be no unreachable code. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Unreachable Data Flow" language=c++ # JSF++:187: All non-null statements shall potentially have a side-effect. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Unused Value" language=c++ # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Use After Close" language=c++ # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # JSF++:81: The assignment operator shall handle self-assignment correctly. # This check is enabled by default for the language(s) C, C++, x86, x86_64 # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Use After Free" language=c++ # JSF++:29: The #define pre-processor directive shall not be used to create inline macros. Inline functions shall be used instead. # JSF++:30: The #define pre-processor directive shall not be used to define constant values. Instead, the const qualifier shall be applied to variable declarations to specify constant values. # JSF++:31: The #define pre-processor directive will only be used as part of the technique to prevent multiple inclusions of the same header file. WARNING_FILTER += allow class="Use of #define" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #elif" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #elifdef" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #elifndef" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #else" language=c++ # JSF++:28: The #ifndef and #endif pre-processor directives will only be used as defined in AV Rule 27 to prevent multiple inclusions of the same header file. WARNING_FILTER += allow class="Use of #endif" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #error" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #if" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #ifdef" language=c++ # JSF++:28: The #ifndef and #endif pre-processor directives will only be used as defined in AV Rule 27 to prevent multiple inclusions of the same header file. WARNING_FILTER += allow class="Use of #ifndef" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #import" language=c++ # JSF++:32: The #include pre-processor directive will only be used to include header (*.h) files. WARNING_FILTER += allow class="Use of #include" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #include_next" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #line" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #pragma" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #using" language=c++ # JSF++:26: Only the following pre-processor directives shall be used: #ifndef, #define, #endif, #include. WARNING_FILTER += allow class="Use of #warning" language=c++ # JSF++:21: The signal handling facilities of shall not be used. WARNING_FILTER += allow class="Use of " language=c++ # JSF++:22: The input/output library shall not be used. WARNING_FILTER += allow class="Use of Input/Output" language=c++ # JSF++:22: The input/output library shall not be used. WARNING_FILTER += allow class="Use of Input/Output Macro" language=c++ # JSF++:25: The time handling functions of library shall not be used. WARNING_FILTER += allow class="Use of Time/Date Function" language=c++ # JSF++:13: Multi-byte characters and wide string literals will not be used. WARNING_FILTER += allow class="Use of Input/Output Macro" language=c++ # JSF++:168: The comma operator shall not be used. WARNING_FILTER += allow class="Use of Comma Operator" language=c++ # JSF++:175: A pointer shall not be compared to NULL or be assigned NULL; use plain 0 instead. WARNING_FILTER += allow class="Use of NULL" language=c++ # JSF++:24: The library functions abort, exit, getenv and system from library shall not be used. WARNING_FILTER += allow class="Use of abort" language=c++ # JSF++:23: The library functions atof, atoi and atol from library shall not be used. WARNING_FILTER += allow class="Use of atof" language=c++ # JSF++:23: The library functions atof, atoi and atol from library shall not be used. WARNING_FILTER += allow class="Use of atoi" language=c++ # JSF++:23: The library functions atof, atoi and atol from library shall not be used. WARNING_FILTER += allow class="Use of atol" language=c++ # JSF++:208: C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.) WARNING_FILTER += allow class="Use of catch" language=c++ # JSF++:24: The library functions abort, exit, getenv and system from library shall not be used. WARNING_FILTER += allow class="Use of exit" language=c++ # JSF++:24: The library functions abort, exit, getenv and system from library shall not be used. WARNING_FILTER += allow class="Use of getenv" language=c++ # JSF++:20: The setjmp macro and the longjmp function shall not be used. WARNING_FILTER += allow class="Use of longjmp" language=c++ # JSF++:18: The macro offsetof, in library , shall not be used. WARNING_FILTER += allow class="Use of offsetof" language=c++ # JSF++:20: The setjmp macro and the longjmp function shall not be used. WARNING_FILTER += allow class="Use of setjmp" language=c++ # JSF++:19: and the setlocale function shall not be used. WARNING_FILTER += allow class="Use of setlocale" language=c++ # JSF++:24: The library functions abort, exit, getenv and system from library shall not be used. WARNING_FILTER += allow class="Use of system" language=c++ # JSF++:208: C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.) WARNING_FILTER += allow class="Use of throw" language=c++ # JSF++:187: All non-null statements shall potentially have a side-effect. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Useless Assignment" language=c++ # JSF++:183: Every possible measure should be taken to avoid type casting. # This check is enabled by default for the language(s) C, C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Varargs Function Cast" language=c++ # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # JSF++:71: Calls to an externally visible operation of an object, other than its constructors, shall not be allowed until the object has been fully initialized. # JSF++:71.1: A class's virtual functions shall not be invoked from its destructor or any of its constructors. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Virtual Call in Constructor" language=c++ # JSF++:70.1: An object shall not be improperly used before its lifetime begins or after its lifetime ends. # JSF++:71.1: A class's virtual functions shall not be invoked from its destructor or any of its constructors. # This check is enabled by default for the language(s) C++ # It may remain in effect even if the following line is commented out. WARNING_FILTER += allow class="Virtual Call in Destructor" language=c++ # JSF++:89: A base class shall not be both virtual and non-virtual in the same hierarchy. WARNING_FILTER += allow class="Virtual and Non-Virtual Base Class" language=c++ # JSF++:218: Compiler warning levels will be set in compliance with project policies. WARNING_FILTER += allow class="Warnings Not Treated As Errors" language=c++ # JSF++:78: All base classes with a virtual function shall define a virtual destructor. WARNING_FILTER += allow class="delete with Non-Virtual Destructor" language=c++ # JSF++:148: Enumeration types shall be used instead of integer types (and constants) to select from a limited series of choices. WARNING_FILTER += allow class="switch With Non-enum Expression" language=c++ # # The remainder of this file was generated from template 'codesonar/presets/jsf++_inc.conf.in' # WARNING_FILTER += discard class="Basic Numerical Type Used" line_contents=~\<(main|argc|argv)\>