532 lines
30 KiB
Python
532 lines
30 KiB
Python
# python3
|
|
# Copyright (C) 2019 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""Warning patterns for C/C++ compiler, but not clang-tidy."""
|
|
|
|
# No need of doc strings for trivial small functions.
|
|
# pylint:disable=missing-function-docstring
|
|
|
|
import re
|
|
|
|
# pylint:disable=relative-beyond-top-level
|
|
from .severity import Severity
|
|
|
|
|
|
def cpp_warn(severity, description, pattern_list):
|
|
return {
|
|
'category': 'C/C++',
|
|
'severity': severity,
|
|
'description': description,
|
|
'patterns': pattern_list
|
|
}
|
|
|
|
|
|
def fixmenow(description, pattern_list):
|
|
return cpp_warn(Severity.FIXMENOW, description, pattern_list)
|
|
|
|
|
|
def high(description, pattern_list):
|
|
return cpp_warn(Severity.HIGH, description, pattern_list)
|
|
|
|
|
|
def medium(description, pattern_list):
|
|
return cpp_warn(Severity.MEDIUM, description, pattern_list)
|
|
|
|
|
|
def low(description, pattern_list):
|
|
return cpp_warn(Severity.LOW, description, pattern_list)
|
|
|
|
|
|
def skip(description, pattern_list):
|
|
return cpp_warn(Severity.SKIP, description, pattern_list)
|
|
|
|
|
|
def harmless(description, pattern_list):
|
|
return cpp_warn(Severity.HARMLESS, description, pattern_list)
|
|
|
|
|
|
warn_patterns = [
|
|
# pylint does not recognize g-inconsistent-quotes
|
|
# pylint:disable=line-too-long,bad-option-value,g-inconsistent-quotes
|
|
medium('Implicit function declaration',
|
|
[r".*: warning: implicit declaration of function .+",
|
|
r".*: warning: implicitly declaring library function"]),
|
|
skip('skip, conflicting types for ...',
|
|
[r".*: warning: conflicting types for '.+'"]),
|
|
high('Expression always evaluates to true or false',
|
|
[r".*: warning: comparison is always .+ due to limited range of data type",
|
|
r".*: warning: comparison of unsigned .*expression .+ is always true",
|
|
r".*: warning: comparison of unsigned .*expression .+ is always false"]),
|
|
high('Use transient memory for control value',
|
|
[r".*: warning: .+Using such transient memory for the control value is .*dangerous."]),
|
|
high('Return address of stack memory',
|
|
[r".*: warning: Address of stack memory .+ returned to caller",
|
|
r".*: warning: Address of stack memory .+ will be a dangling reference"]),
|
|
high('Infinite recursion',
|
|
[r".*: warning: all paths through this function will call itself"]),
|
|
high('Potential buffer overflow',
|
|
[r".*: warning: Size argument is greater than .+ the destination buffer",
|
|
r".*: warning: Potential buffer overflow.",
|
|
r".*: warning: String copy function overflows destination buffer"]),
|
|
medium('Incompatible pointer types',
|
|
[r".*: warning: assignment from incompatible pointer type",
|
|
r".*: warning: return from incompatible pointer type",
|
|
r".*: warning: passing argument [0-9]+ of '.*' from incompatible pointer type",
|
|
r".*: warning: initialization from incompatible pointer type"]),
|
|
high('Incompatible declaration of built in function',
|
|
[r".*: warning: incompatible implicit declaration of built-in function .+"]),
|
|
high('Incompatible redeclaration of library function',
|
|
[r".*: warning: incompatible redeclaration of library function .+"]),
|
|
high('Null passed as non-null argument',
|
|
[r".*: warning: Null passed to a callee that requires a non-null"]),
|
|
medium('Unused command line argument',
|
|
[r".*: warning: argument unused during compilation: .+"]),
|
|
medium('Set but not used',
|
|
[r".*: warning: .* set but not used.*Wunused-but-set"]),
|
|
medium('Unused parameter',
|
|
[r".*: warning: unused parameter '.*'"]),
|
|
medium('Unused function, variable, label, comparison, etc.',
|
|
[r".*: warning: '.+' defined but not used",
|
|
r".*: warning: unused function '.+'",
|
|
r".*: warning: unused label '.+'",
|
|
r".*: warning: relational comparison result unused",
|
|
r".*: warning: lambda capture .* is not used",
|
|
r".*: warning: private field '.+' is not used",
|
|
r".*: warning: unused variable '.+'"]),
|
|
medium('Statement with no effect or result unused',
|
|
[r".*: warning: statement with no effect",
|
|
r".*: warning: expression result unused"]),
|
|
medium('Ignoreing return value of function',
|
|
[r".*: warning: ignoring return value of function .+Wunused-result"]),
|
|
medium('Missing initializer',
|
|
[r".*: warning: missing initializer"]),
|
|
medium('Need virtual destructor',
|
|
[r".*: warning: delete called .* has virtual functions but non-virtual destructor"]),
|
|
skip('skip, near initialization for ...',
|
|
[r".*: warning: \(near initialization for '.+'\)"]),
|
|
medium('Expansion of data or time macro',
|
|
[r".*: warning: expansion of date or time macro is not reproducible"]),
|
|
medium('Macro expansion has undefined behavior',
|
|
[r".*: warning: macro expansion .* has undefined behavior"]),
|
|
medium('Format string does not match arguments',
|
|
[r".*: warning: format '.+' expects type '.+', but argument [0-9]+ has type '.+'",
|
|
r".*: warning: more '%' conversions than data arguments",
|
|
r".*: warning: data argument not used by format string",
|
|
r".*: warning: incomplete format specifier",
|
|
r".*: warning: unknown conversion type .* in format",
|
|
r".*: warning: format .+ expects .+ but argument .+Wformat=",
|
|
r".*: warning: field precision should have .+ but argument has .+Wformat",
|
|
r".*: warning: format specifies type .+ but the argument has .*type .+Wformat"]),
|
|
medium('Too many arguments for format string',
|
|
[r".*: warning: too many arguments for format"]),
|
|
medium('Too many arguments in call',
|
|
[r".*: warning: too many arguments in call to "]),
|
|
medium('Invalid format specifier',
|
|
[r".*: warning: invalid .+ specifier '.+'.+format-invalid-specifier"]),
|
|
medium('Comparison between signed and unsigned',
|
|
[r".*: warning: comparison between signed and unsigned",
|
|
r".*: warning: comparison of promoted \~unsigned with unsigned",
|
|
r".*: warning: signed and unsigned type in conditional expression"]),
|
|
medium('Comparison between enum and non-enum',
|
|
[r".*: warning: enumeral and non-enumeral type in conditional expression"]),
|
|
medium('libpng: zero area',
|
|
[r".*libpng warning: Ignoring attempt to set cHRM RGB triangle with zero area"]),
|
|
medium('Missing braces around initializer',
|
|
[r".*: warning: missing braces around initializer.*"]),
|
|
harmless('No newline at end of file',
|
|
[r".*: warning: no newline at end of file"]),
|
|
harmless('Missing space after macro name',
|
|
[r".*: warning: missing whitespace after the macro name"]),
|
|
low('Cast increases required alignment',
|
|
[r".*: warning: cast from .* to .* increases required alignment .*"]),
|
|
medium('Qualifier discarded',
|
|
[r".*: warning: passing argument [0-9]+ of '.+' discards qualifiers from pointer target type",
|
|
r".*: warning: assignment discards qualifiers from pointer target type",
|
|
r".*: warning: passing .+ to parameter of type .+ discards qualifiers",
|
|
r".*: warning: assigning to .+ from .+ discards qualifiers",
|
|
r".*: warning: initializing .+ discards qualifiers .+types-discards-qualifiers",
|
|
r".*: warning: return discards qualifiers from pointer target type"]),
|
|
medium('Unknown attribute',
|
|
[r".*: warning: unknown attribute '.+'"]),
|
|
medium('Attribute ignored',
|
|
[r".*: warning: '_*packed_*' attribute ignored",
|
|
r".*: warning: .* not supported .*Wignored-attributes",
|
|
r".*: warning: attribute declaration must precede definition .+ignored-attributes"]),
|
|
medium('Visibility problem',
|
|
[r".*: warning: declaration of '.+' will not be visible outside of this function"]),
|
|
medium('Visibility mismatch',
|
|
[r".*: warning: '.+' declared with greater visibility than the type of its field '.+'"]),
|
|
medium('Shift count greater than width of type',
|
|
[r".*: warning: (left|right) shift count >= width of type"]),
|
|
medium('Shift operator precedence',
|
|
[r".*: warning: operator .* has lower precedence .+Wshift-op-parentheses.+"]),
|
|
medium('extern <foo> is initialized',
|
|
[r".*: warning: '.+' initialized and declared 'extern'",
|
|
r".*: warning: 'extern' variable has an initializer"]),
|
|
medium('Old style declaration',
|
|
[r".*: warning: 'static' is not at beginning of declaration"]),
|
|
medium('Missing return value',
|
|
[r".*: warning: control reaches end of non-void function"]),
|
|
medium('Implicit int type',
|
|
[r".*: warning: type specifier missing, defaults to 'int'",
|
|
r".*: warning: type defaults to 'int' in declaration of '.+'"]),
|
|
medium('Main function should return int',
|
|
[r".*: warning: return type of 'main' is not 'int'"]),
|
|
medium('Variable may be used uninitialized',
|
|
[r".*: warning: '.+' may be used uninitialized in this function"]),
|
|
high('Variable is used uninitialized',
|
|
[r".*: warning: '.+' is used uninitialized in this function",
|
|
r".*: warning: variable '.+' is uninitialized when used here"]),
|
|
medium('ld: possible enum size mismatch',
|
|
[r".*: warning: .* uses variable-size enums yet the output is to use 32-bit enums; use of enum values across objects may fail"]),
|
|
medium('Pointer targets differ in signedness',
|
|
[r".*: warning: pointer targets in initialization differ in signedness",
|
|
r".*: warning: pointer targets in assignment differ in signedness",
|
|
r".*: warning: pointer targets in return differ in signedness",
|
|
r".*: warning: pointer targets in passing argument [0-9]+ of '.+' differ in signedness"]),
|
|
medium('Assuming overflow does not occur',
|
|
[r".*: warning: assuming signed overflow does not occur when assuming that .* is always (true|false)"]),
|
|
medium('Suggest adding braces around empty body',
|
|
[r".*: warning: suggest braces around empty body in an 'if' statement",
|
|
r".*: warning: empty body in an if-statement",
|
|
r".*: warning: suggest braces around empty body in an 'else' statement",
|
|
r".*: warning: empty body in an else-statement"]),
|
|
medium('Suggest adding parentheses',
|
|
[r".*: warning: suggest explicit braces to avoid ambiguous 'else'",
|
|
r".*: warning: suggest parentheses around arithmetic in operand of '.+'",
|
|
r".*: warning: suggest parentheses around comparison in operand of '.+'",
|
|
r".*: warning: logical not is only applied to the left hand side of this comparison",
|
|
r".*: warning: using the result of an assignment as a condition without parentheses",
|
|
r".*: warning: .+ has lower precedence than .+ be evaluated first .+Wparentheses",
|
|
r".*: warning: suggest parentheses around '.+?' .+ '.+?'",
|
|
r".*: warning: suggest parentheses around assignment used as truth value"]),
|
|
medium('Static variable used in non-static inline function',
|
|
[r".*: warning: '.+' is static but used in inline function '.+' which is not static"]),
|
|
medium('No type or storage class (will default to int)',
|
|
[r".*: warning: data definition has no type or storage class"]),
|
|
skip('skip, parameter name (without types) in function declaration',
|
|
[r".*: warning: parameter names \(without types\) in function declaration"]),
|
|
medium('Dereferencing <foo> breaks strict aliasing rules',
|
|
[r".*: warning: dereferencing .* break strict-aliasing rules"]),
|
|
medium('Cast from pointer to integer of different size',
|
|
[r".*: warning: cast from pointer to integer of different size",
|
|
r".*: warning: initialization makes pointer from integer without a cast"]),
|
|
medium('Cast to pointer from integer of different size',
|
|
[r".*: warning: cast to pointer from integer of different size"]),
|
|
medium('Macro redefined',
|
|
[r".*: warning: '.+' macro redefined"]),
|
|
skip('skip, ... location of the previous definition',
|
|
[r".*: warning: this is the location of the previous definition"]),
|
|
medium('ld: type and size of dynamic symbol are not defined',
|
|
[r".*: warning: type and size of dynamic symbol `.+' are not defined"]),
|
|
medium('Pointer from integer without cast',
|
|
[r".*: warning: assignment makes pointer from integer without a cast"]),
|
|
medium('Pointer from integer without cast',
|
|
[r".*: warning: passing argument [0-9]+ of '.+' makes pointer from integer without a cast"]),
|
|
medium('Integer from pointer without cast',
|
|
[r".*: warning: assignment makes integer from pointer without a cast"]),
|
|
medium('Integer from pointer without cast',
|
|
[r".*: warning: passing argument [0-9]+ of '.+' makes integer from pointer without a cast"]),
|
|
medium('Integer from pointer without cast',
|
|
[r".*: warning: return makes integer from pointer without a cast"]),
|
|
medium('Ignoring pragma',
|
|
[r".*: warning: ignoring #pragma .+"]),
|
|
medium('Pragma warning messages',
|
|
[r".*: warning: .+W#pragma-messages"]),
|
|
medium('Pragma once in main file',
|
|
[r".*: warning: #pragma once in main file .+Wpragma-once-outside-header.*"]),
|
|
medium('Variable might be clobbered by longjmp or vfork',
|
|
[r".*: warning: variable '.+' might be clobbered by 'longjmp' or 'vfork'"]),
|
|
medium('Argument might be clobbered by longjmp or vfork',
|
|
[r".*: warning: argument '.+' might be clobbered by 'longjmp' or 'vfork'"]),
|
|
medium('Redundant declaration',
|
|
[r".*: warning: redundant redeclaration of '.+'"]),
|
|
skip('skip, previous declaration ... was here',
|
|
[r".*: warning: previous declaration of '.+' was here"]),
|
|
high('Enum value not handled in switch',
|
|
[r".*: warning: .*enumeration value.* not handled in switch.+Wswitch"]),
|
|
medium('User defined warnings',
|
|
[r".*: warning: .* \[-Wuser-defined-warnings\]$"]),
|
|
medium('Taking address of temporary',
|
|
[r".*: warning: taking address of temporary"]),
|
|
medium('Taking address of packed member',
|
|
[r".*: warning: taking address of packed member"]),
|
|
medium('Pack alignment value is modified',
|
|
[r".*: warning: .*#pragma pack alignment value is modified.*Wpragma-pack.*"]),
|
|
medium('Possible broken line continuation',
|
|
[r".*: warning: backslash and newline separated by space"]),
|
|
medium('Undefined variable template',
|
|
[r".*: warning: instantiation of variable .* no definition is available"]),
|
|
medium('Inline function is not defined',
|
|
[r".*: warning: inline function '.*' is not defined"]),
|
|
medium('Excess elements in initializer',
|
|
[r".*: warning: excess elements in .+ initializer"]),
|
|
medium('Decimal constant is unsigned only in ISO C90',
|
|
[r".*: warning: this decimal constant is unsigned only in ISO C90"]),
|
|
medium('main is usually a function',
|
|
[r".*: warning: 'main' is usually a function"]),
|
|
medium('Typedef ignored',
|
|
[r".*: warning: 'typedef' was ignored in this declaration"]),
|
|
high('Address always evaluates to true',
|
|
[r".*: warning: the address of '.+' will always evaluate as 'true'"]),
|
|
fixmenow('Freeing a non-heap object',
|
|
[r".*: warning: attempt to free a non-heap object '.+'"]),
|
|
medium('Array subscript has type char',
|
|
[r".*: warning: array subscript .+ type 'char'.+Wchar-subscripts"]),
|
|
medium('Constant too large for type',
|
|
[r".*: warning: integer constant is too large for '.+' type"]),
|
|
medium('Constant too large for type, truncated',
|
|
[r".*: warning: large integer implicitly truncated to unsigned type"]),
|
|
medium('Overflow in expression',
|
|
[r".*: warning: overflow in expression; .*Winteger-overflow"]),
|
|
medium('Overflow in implicit constant conversion',
|
|
[r".*: warning: overflow in implicit constant conversion"]),
|
|
medium('Declaration does not declare anything',
|
|
[r".*: warning: declaration 'class .+' does not declare anything"]),
|
|
medium('Initialization order will be different',
|
|
[r".*: warning: '.+' will be initialized after",
|
|
r".*: warning: initializer order does not match the declaration order",
|
|
r".*: warning: field .+ will be initialized after .+Wreorder"]),
|
|
skip('skip, ....',
|
|
[r".*: warning: '.+'"]),
|
|
skip('skip, base ...',
|
|
[r".*: warning: base '.+'"]),
|
|
skip('skip, when initialized here',
|
|
[r".*: warning: when initialized here"]),
|
|
medium('Parameter type not specified',
|
|
[r".*: warning: type of '.+' defaults to 'int'"]),
|
|
medium('Missing declarations',
|
|
[r".*: warning: declaration does not declare anything"]),
|
|
medium('Missing noreturn',
|
|
[r".*: warning: function '.*' could be declared with attribute 'noreturn'"]),
|
|
medium('User warning',
|
|
[r".*: warning: #warning \".+\""]),
|
|
medium('Vexing parsing problem',
|
|
[r".*: warning: empty parentheses interpreted as a function declaration"]),
|
|
medium('Dereferencing void*',
|
|
[r".*: warning: dereferencing 'void \*' pointer"]),
|
|
medium('Comparison of pointer and integer',
|
|
[r".*: warning: ordered comparison of pointer with integer zero",
|
|
r".*: warning: .*comparison between pointer and integer"]),
|
|
medium('Use of error-prone unary operator',
|
|
[r".*: warning: use of unary operator that may be intended as compound assignment"]),
|
|
medium('Conversion of string constant to non-const char*',
|
|
[r".*: warning: deprecated conversion from string constant to '.+'"]),
|
|
medium('Function declaration isn''t a prototype',
|
|
[r".*: warning: function declaration isn't a prototype"]),
|
|
medium('Type qualifiers ignored on function return value',
|
|
[r".*: warning: type qualifiers ignored on function return type",
|
|
r".*: warning: .+ type qualifier .+ has no effect .+Wignored-qualifiers"]),
|
|
medium('<foo> declared inside parameter list, scope limited to this definition',
|
|
[r".*: warning: '.+' declared inside parameter list"]),
|
|
skip('skip, its scope is only this ...',
|
|
[r".*: warning: its scope is only this definition or declaration, which is probably not what you want"]),
|
|
low('Line continuation inside comment',
|
|
[r".*: warning: multi-line comment"]),
|
|
low('Comment inside comment',
|
|
[r".*: warning: '.+' within block comment .*-Wcomment"]),
|
|
low('Deprecated declarations',
|
|
[r".*: warning: .+ is deprecated.+deprecated-declarations"]),
|
|
low('Deprecated register',
|
|
[r".*: warning: 'register' storage class specifier is deprecated"]),
|
|
low('Converts between pointers to integer types with different sign',
|
|
[r".*: warning: .+ converts between pointers to integer types .+Wpointer-sign\]"]),
|
|
harmless('Extra tokens after #endif',
|
|
[r".*: warning: extra tokens at end of #endif directive"]),
|
|
medium('Comparison between different enums',
|
|
[r".*: warning: comparison between '.+' and '.+'.+Wenum-compare",
|
|
r".*: warning: comparison of .* enumeration types .*-Wenum-compare.*"]),
|
|
medium('Conversion may change value',
|
|
[r".*: warning: converting negative value '.+' to '.+'",
|
|
r".*: warning: conversion to '.+' .+ may (alter|change)"]),
|
|
medium('Converting to non-pointer type from NULL',
|
|
[r".*: warning: converting to non-pointer type '.+' from NULL"]),
|
|
medium('Implicit sign conversion',
|
|
[r".*: warning: implicit conversion changes signedness"]),
|
|
medium('Converting NULL to non-pointer type',
|
|
[r".*: warning: implicit conversion of NULL constant to '.+'"]),
|
|
medium('Zero used as null pointer',
|
|
[r".*: warning: expression .* zero treated as a null pointer constant"]),
|
|
medium('Compare pointer to null character',
|
|
[r".*: warning: comparing a pointer to a null character constant"]),
|
|
medium('Implicit conversion changes value or loses precision',
|
|
[r".*: warning: implicit conversion .* changes value from .* to .*-conversion",
|
|
r".*: warning: implicit conversion loses integer precision:"]),
|
|
medium('Passing NULL as non-pointer argument',
|
|
[r".*: warning: passing NULL to non-pointer argument [0-9]+ of '.+'"]),
|
|
medium('Class seems unusable because of private ctor/dtor',
|
|
[r".*: warning: all member functions in class '.+' are private"]),
|
|
# skip this next one, because it only points out some RefBase-based classes
|
|
# where having a private destructor is perfectly fine
|
|
skip('Class seems unusable because of private ctor/dtor',
|
|
[r".*: warning: 'class .+' only defines a private destructor and has no friends"]),
|
|
medium('Class seems unusable because of private ctor/dtor',
|
|
[r".*: warning: 'class .+' only defines private constructors and has no friends"]),
|
|
medium('In-class initializer for static const float/double',
|
|
[r".*: warning: in-class initializer for static data member of .+const (float|double)"]),
|
|
medium('void* used in arithmetic',
|
|
[r".*: warning: pointer of type 'void \*' used in (arithmetic|subtraction)",
|
|
r".*: warning: arithmetic on .+ to void is a GNU extension.*Wpointer-arith",
|
|
r".*: warning: wrong type argument to increment"]),
|
|
medium('Overload resolution chose to promote from unsigned or enum to signed type',
|
|
[r".*: warning: passing '.+' chooses '.+' over '.+'.*Wsign-promo"]),
|
|
skip('skip, in call to ...',
|
|
[r".*: warning: in call to '.+'"]),
|
|
high('Base should be explicitly initialized in copy constructor',
|
|
[r".*: warning: base class '.+' should be explicitly initialized in the copy constructor"]),
|
|
medium('Return value from void function',
|
|
[r".*: warning: 'return' with a value, in function returning void"]),
|
|
medium('Multi-character character constant',
|
|
[r".*: warning: multi-character character constant"]),
|
|
medium('Conversion from string literal to char*',
|
|
[r".*: warning: .+ does not allow conversion from string literal to 'char \*'"]),
|
|
low('Extra \';\'',
|
|
[r".*: warning: extra ';' .+extra-semi"]),
|
|
low('Useless specifier',
|
|
[r".*: warning: useless storage class specifier in empty declaration"]),
|
|
low('Duplicate declaration specifier',
|
|
[r".*: warning: duplicate '.+' declaration specifier"]),
|
|
low('Comparison of self is always false',
|
|
[r".*: self-comparison always evaluates to false"]),
|
|
low('Logical op with constant operand',
|
|
[r".*: use of logical '.+' with constant operand"]),
|
|
low('Needs a space between literal and string macro',
|
|
[r".*: warning: invalid suffix on literal.+ requires a space .+Wliteral-suffix"]),
|
|
low('Warnings from #warning',
|
|
[r".*: warning: .+-W#warnings"]),
|
|
low('Using float/int absolute value function with int/float argument',
|
|
[r".*: warning: using .+ absolute value function .+ when argument is .+ type .+Wabsolute-value",
|
|
r".*: warning: absolute value function '.+' given .+ which may cause truncation .+Wabsolute-value"]),
|
|
low('Using C++11 extensions',
|
|
[r".*: warning: 'auto' type specifier is a C\+\+11 extension"]),
|
|
low('Using C++17 extensions',
|
|
[r".*: warning: .* a C\+\+17 extension .+Wc\+\+17-extensions"]),
|
|
low('Refers to implicitly defined namespace',
|
|
[r".*: warning: using directive refers to implicitly-defined namespace .+"]),
|
|
low('Invalid pp token',
|
|
[r".*: warning: missing .+Winvalid-pp-token"]),
|
|
low('need glibc to link',
|
|
[r".*: warning: .* requires at runtime .* glibc .* for linking"]),
|
|
low('Add braces to avoid dangling else',
|
|
[r".*: warning: add explicit braces to avoid dangling else"]),
|
|
low('Assigning value to self',
|
|
[r".*: warning: explicitly assigning value of .+ to itself"]),
|
|
low('Comparison of integers of different signs',
|
|
[r".*: warning: comparison of integers of different signs.+sign-compare"]),
|
|
low('Incompatible pointer types',
|
|
[r".*: warning: incompatible .*pointer types .*-Wincompatible-.*pointer-types"]),
|
|
low('Missing braces',
|
|
[r".*: warning: suggest braces around initialization of",
|
|
r".*: warning: too many braces around scalar initializer .+Wmany-braces-around-scalar-init",
|
|
r".*: warning: braces around scalar initializer"]),
|
|
low('Missing field initializers',
|
|
[r".*: warning: missing field '.+' initializer"]),
|
|
low('Typedef redefinition',
|
|
[r".*: warning: redefinition of typedef '.+' is a C11 feature"]),
|
|
low('GNU old-style field designator',
|
|
[r".*: warning: use of GNU old-style field designator extension"]),
|
|
low('Initializer overrides prior initialization',
|
|
[r".*: warning: initializer overrides prior initialization of this subobject"]),
|
|
low('GNU extension, variable sized type not at end',
|
|
[r".*: warning: field '.+' with variable sized type '.+' not at the end of a struct or class"]),
|
|
low('Comparison of constant is always false/true',
|
|
[r".*: comparison of .+ is always .+Wtautological-constant-out-of-range-compare"]),
|
|
low('Hides overloaded virtual function',
|
|
[r".*: '.+' hides overloaded virtual function"]),
|
|
medium('Operator new returns NULL',
|
|
[r".*: warning: 'operator new' must not return NULL unless it is declared 'throw\(\)' .+"]),
|
|
medium('NULL used in arithmetic',
|
|
[r".*: warning: NULL used in arithmetic",
|
|
r".*: warning: .* subtraction with a null pointer",
|
|
r".*: warning: comparison between NULL and non-pointer"]),
|
|
medium('Misspelled header guard',
|
|
[r".*: warning: '.+' is used as a header guard .+ followed by .+ different macro"]),
|
|
medium('Empty loop body',
|
|
[r".*: warning: .+ loop has empty body"]),
|
|
medium('Implicit conversion from enumeration type',
|
|
[r".*: warning: implicit conversion from enumeration type '.+'"]),
|
|
medium('case value not in enumerated type',
|
|
[r".*: warning: case value not in enumerated type '.+'"]),
|
|
medium('Use of deprecated method',
|
|
[r".*: warning: '.+' is deprecated .+"]),
|
|
medium('Use of garbage or uninitialized value',
|
|
[r".*: warning: .+ uninitialized .+\[-Wsometimes-uninitialized\]"]),
|
|
medium('Sizeof on array argument',
|
|
[r".*: warning: sizeof on array function parameter will return"]),
|
|
medium('Bad argument size of memory access functions',
|
|
[r".*: warning: .+\[-Wsizeof-pointer-memaccess\]"]),
|
|
medium('Return value not checked',
|
|
[r".*: warning: The return value from .+ is not checked"]),
|
|
medium('Possible heap pollution',
|
|
[r".*: warning: .*Possible heap pollution from .+ type .+"]),
|
|
medium('Variable used in loop condition not modified in loop body',
|
|
[r".*: warning: variable '.+' used in loop condition.*Wfor-loop-analysis"]),
|
|
medium('Closing a previously closed file',
|
|
[r".*: warning: Closing a previously closed file"]),
|
|
medium('Unnamed template type argument',
|
|
[r".*: warning: template argument.+Wunnamed-type-template-args"]),
|
|
medium('Unannotated fall-through between switch labels',
|
|
[r".*: warning: unannotated fall-through between switch labels.+Wimplicit-fallthrough"]),
|
|
medium('Invalid partial specialization',
|
|
[r".*: warning: class template partial specialization.+Winvalid-partial-specialization"]),
|
|
medium('Overlapping comparisons',
|
|
[r".*: warning: overlapping comparisons.+Wtautological-overlap-compare"]),
|
|
medium('bitwise comparison',
|
|
[r".*: warning: bitwise comparison.+Wtautological-bitwise-compare"]),
|
|
medium('int in bool context',
|
|
[r".*: warning: converting.+to a boolean.+Wint-in-bool-context"]),
|
|
medium('bitwise conditional parentheses',
|
|
[r".*: warning: operator.+has lower precedence.+Wbitwise-conditional-parentheses"]),
|
|
medium('sizeof array div',
|
|
[r".*: warning: .+number of elements in.+array.+Wsizeof-array-div"]),
|
|
medium('bool operation',
|
|
[r".*: warning: .+boolean.+always.+Wbool-operation"]),
|
|
medium('Undefined bool conversion',
|
|
[r".*: warning: .+may be.+always.+true.+Wundefined-bool-conversion"]),
|
|
medium('Typedef requires a name',
|
|
[r".*: warning: typedef requires a name.+Wmissing-declaration"]),
|
|
medium('Unknown escape sequence',
|
|
[r".*: warning: unknown escape sequence.+Wunknown-escape-sequence"]),
|
|
medium('Unicode whitespace',
|
|
[r".*: warning: treating Unicode.+as whitespace.+Wunicode-whitespace"]),
|
|
medium('Unused local typedef',
|
|
[r".*: warning: unused typedef.+Wunused-local-typedef"]),
|
|
medium('varargs warnings',
|
|
[r".*: warning: .*argument to 'va_start'.+\[-Wvarargs\]"]),
|
|
harmless('Discarded qualifier from pointer target type',
|
|
[r".*: warning: .+ discards '.+' qualifier from pointer target type"]),
|
|
harmless('Use snprintf instead of sprintf',
|
|
[r".*: warning: .*sprintf is often misused; please use snprintf"]),
|
|
harmless('Unsupported optimizaton flag',
|
|
[r".*: warning: optimization flag '.+' is not supported"]),
|
|
harmless('Extra or missing parentheses',
|
|
[r".*: warning: equality comparison with extraneous parentheses",
|
|
r".*: warning: .+ within .+Wlogical-op-parentheses"]),
|
|
harmless('Mismatched class vs struct tags',
|
|
[r".*: warning: '.+' defined as a .+ here but previously declared as a .+mismatched-tags",
|
|
r".*: warning: .+ was previously declared as a .+mismatched-tags"]),
|
|
]
|
|
|
|
|
|
def compile_patterns(patterns):
|
|
"""Precompiling every pattern speeds up parsing by about 30x."""
|
|
for i in patterns:
|
|
i['compiled_patterns'] = []
|
|
for pat in i['patterns']:
|
|
i['compiled_patterns'].append(re.compile(pat))
|
|
|
|
|
|
compile_patterns(warn_patterns)
|